faraday 1.10.3 → 2.0.0.alpha.pre.1

data/spec/faraday/adapter/httpclient_spec.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Adapter::HTTPClient do
-  # ruby gem defaults for testing purposes
-  HTTPCLIENT_OPEN = 60
-  HTTPCLIENT_READ = 60
-  HTTPCLIENT_WRITE = 120
-
-  features :request_body_on_query_methods, :reason_phrase_parse, :compression,
-           :trace_method, :local_socket_binding
-
-  it_behaves_like 'an adapter'
-
-  it 'allows to provide adapter specific configs' do
-    adapter = described_class.new do |client|
-      client.keep_alive_timeout = 20
-      client.ssl_config.timeout = 25
-    end
-
-    client = adapter.build_connection(url: URI.parse('https://example.com'))
-    expect(client.keep_alive_timeout).to eq(20)
-    expect(client.ssl_config.timeout).to eq(25)
-  end
-
-  context 'Options' do
-    let(:request) { Faraday::RequestOptions.new }
-    let(:env) { { request: request } }
-    let(:options) { {} }
-    let(:adapter) { Faraday::Adapter::HTTPClient.new }
-    let(:client) { adapter.connection(url: URI.parse('https://example.com')) }
-
-    it 'configures timeout' do
-      assert_default_timeouts!
-
-      request.timeout = 5
-      adapter.configure_timeouts(client, request)
-
-      expect(client.connect_timeout).to eq(5)
-      expect(client.send_timeout).to eq(5)
-      expect(client.receive_timeout).to eq(5)
-    end
-
-    it 'configures open timeout' do
-      assert_default_timeouts!
-
-      request.open_timeout = 1
-      adapter.configure_timeouts(client, request)
-
-      expect(client.connect_timeout).to eq(1)
-      expect(client.send_timeout).to eq(HTTPCLIENT_WRITE)
-      expect(client.receive_timeout).to eq(HTTPCLIENT_READ)
-    end
-
-    it 'configures multiple timeouts' do
-      assert_default_timeouts!
-
-      request.open_timeout = 1
-      request.write_timeout = 10
-      request.read_timeout = 5
-      adapter.configure_timeouts(client, request)
-
-      expect(client.connect_timeout).to eq(1)
-      expect(client.send_timeout).to eq(10)
-      expect(client.receive_timeout).to eq(5)
-    end
-
-    def assert_default_timeouts!
-      expect(client.connect_timeout).to eq(HTTPCLIENT_OPEN)
-      expect(client.send_timeout).to eq(HTTPCLIENT_WRITE)
-      expect(client.receive_timeout).to eq(HTTPCLIENT_READ)
-    end
-  end
-end

data/spec/faraday/adapter/net_http_spec.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Adapter::NetHttp do
-  features :request_body_on_query_methods, :reason_phrase_parse, :compression, :streaming, :trace_method
-
-  it_behaves_like 'an adapter'
-
-  context 'checking http' do
-    let(:url) { URI('http://example.com') }
-    let(:adapter) { described_class.new }
-    let(:http) { adapter.send(:connection, url: url, request: {}) }
-
-    it { expect(http.port).to eq(80) }
-
-    it 'sets max_retries to 0' do
-      adapter.send(:configure_request, http, {})
-
-      expect(http.max_retries).to eq(0) if http.respond_to?(:max_retries=)
-    end
-
-    it 'supports write_timeout' do
-      adapter.send(:configure_request, http, write_timeout: 10)
-
-      expect(http.write_timeout).to eq(10) if http.respond_to?(:write_timeout=)
-    end
-
-    it 'supports open_timeout' do
-      adapter.send(:configure_request, http, open_timeout: 10)
-
-      expect(http.open_timeout).to eq(10)
-    end
-
-    it 'supports read_timeout' do
-      adapter.send(:configure_request, http, read_timeout: 10)
-
-      expect(http.read_timeout).to eq(10)
-    end
-
-    context 'with https url' do
-      let(:url) { URI('https://example.com') }
-
-      it { expect(http.port).to eq(443) }
-    end
-
-    context 'with http url including port' do
-      let(:url) { URI('https://example.com:1234') }
-
-      it { expect(http.port).to eq(1234) }
-    end
-
-    context 'with custom adapter config' do
-      let(:adapter) do
-        described_class.new do |http|
-          http.continue_timeout = 123
-        end
-      end
-
-      it do
-        adapter.send(:configure_request, http, {})
-        expect(http.continue_timeout).to eq(123)
-      end
-    end
-  end
-end

data/spec/faraday/adapter/patron_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Adapter::Patron, unless: defined?(JRUBY_VERSION) do
-  features :reason_phrase_parse
-
-  it_behaves_like 'an adapter'
-
-  it 'allows to provide adapter specific configs' do
-    conn = Faraday.new do |f|
-      f.adapter :patron do |session|
-        session.max_redirects = 10
-        raise 'Configuration block called'
-      end
-    end
-
-    expect { conn.get('/') }.to raise_error(RuntimeError, 'Configuration block called')
-  end
-end

data/spec/faraday/adapter/rack_spec.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Adapter::Rack do
-  features :request_body_on_query_methods, :trace_method,
-           :skip_response_body_on_head
-
-  it_behaves_like 'an adapter', adapter_options: WebmockRackApp.new
-end

data/spec/faraday/adapter/typhoeus_spec.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Adapter::Typhoeus do
-  features :request_body_on_query_methods, :parallel, :trace_method
-
-  it_behaves_like 'an adapter'
-end

data/spec/faraday/deprecate_spec.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::DeprecatedClass do
-  class SampleClass < StandardError
-    attr_accessor :foo
-
-    def initialize(foo = nil)
-      @foo = foo || :foo
-    end
-  end
-
-  SampleDeprecatedClass = Faraday::DeprecatedClass.proxy_class(SampleClass)
-
-  it 'does not raise error for deprecated classes but prints an error message' do
-    error_message, foobar = with_warn_squelching { SampleDeprecatedClass.new(:foo_bar) }
-    expect(foobar).to be_a(SampleClass)
-    expect(foobar.foo).to eq(:foo_bar)
-    expect(error_message).to match(
-      Regexp.new(
-        'NOTE: SampleDeprecatedClass.new is deprecated; '\
-        'use SampleClass.new instead. It will be removed in or after version 1.0'
-      )
-    )
-  end
-
-  it 'does not raise an error for inherited error-namespaced classes but prints an error message' do
-    error_message, = with_warn_squelching { Class.new(SampleDeprecatedClass) }
-
-    expect(error_message).to match(
-      Regexp.new(
-        'NOTE: Inheriting SampleDeprecatedClass is deprecated; '\
-        'use SampleClass instead. It will be removed in or after version 1.0'
-      )
-    )
-  end
-
-  it 'allows backward-compatible class to be subclassed' do
-    expect do
-      with_warn_squelching { Class.new(SampleDeprecatedClass) }
-    end.not_to raise_error
-  end
-
-  it 'allows rescuing of a current error with a deprecated error' do
-    expect { raise SampleClass, nil }.to raise_error(SampleDeprecatedClass)
-  end
-
-  it 'allows rescuing of a current error with a current error' do
-    expect { raise SampleClass, nil }.to raise_error(SampleClass)
-  end
-
-  it 'allows rescuing of a deprecated error with a deprecated error' do
-    expect { raise SampleDeprecatedClass, nil }.to raise_error(SampleDeprecatedClass)
-  end
-
-  it 'allows rescuing of a deprecated error with a current error' do
-    expect { raise SampleDeprecatedClass, nil }.to raise_error(SampleClass)
-  end
-
-  describe 'match behavior' do
-    class SampleDeprecatedClassA < SampleDeprecatedClass; end
-    class SampleDeprecatedClassB < SampleDeprecatedClass; end
-
-    class SampleDeprecatedClassAX < SampleDeprecatedClassA; end
-
-    class SampleClassA < SampleClass; end
-
-    describe 'undeprecated class' do
-      it 'is === to instance of deprecated class' do
-        expect(SampleDeprecatedClass.new.is_a?(SampleClass)).to be true
-      end
-
-      it 'is === to instance of subclass of deprecated class' do
-        expect(SampleDeprecatedClassA.new.is_a?(SampleClass)).to be true
-      end
-
-      it 'is === to instance of subclass of subclass of deprecated class' do
-        expect(SampleDeprecatedClassAX.new.is_a?(SampleClass)).to be true
-      end
-    end
-
-    describe 'subclass of undeprecated class' do
-      it 'is not === to instance of undeprecated class' do
-        expect(SampleClass.new.is_a?(SampleClassA)).to be false
-      end
-
-      it 'is not === to instance of deprecated class' do
-        expect(SampleDeprecatedClass.new.is_a?(SampleClassA)).to be false
-      end
-    end
-
-    describe 'deprecated class' do
-      it 'is === to instance of undeprecated class' do
-        expect(SampleDeprecatedClass.new.is_a?(SampleClass)).to be true
-      end
-
-      it 'is === to instance of subclass of undeprecated class' do
-        expect(SampleClassA.superclass == SampleDeprecatedClass.superclass).to be true
-      end
-
-      it 'is === to instance of subclass of deprecated class' do
-        expect(SampleDeprecatedClassA.new.is_a?(SampleDeprecatedClass)).to be true
-      end
-
-      it 'is === to instance of subclass of subclass of deprecated class' do
-        expect(SampleDeprecatedClassAX.new.is_a?(SampleDeprecatedClass)).to be true
-      end
-    end
-
-    describe 'subclass of deprecated class' do
-      it 'is not === to instance of subclass of undeprecated class' do
-        expect(SampleClass.new.is_a?(SampleDeprecatedClassA)).to be false
-      end
-
-      it 'is not === to instance of another subclass of deprecated class' do
-        expect(SampleDeprecatedClassB.new.is_a?(SampleDeprecatedClassA)).to be false
-      end
-
-      it 'is === to instance of its subclass' do
-        expect(SampleDeprecatedClassAX.new.is_a?(SampleDeprecatedClassA)).to be true
-      end
-
-      it 'is === to instance of deprecated class' do
-        expect(SampleDeprecatedClassB.new.is_a?(SampleDeprecatedClass)).to be true
-      end
-    end
-
-    describe 'subclass of subclass of deprecated class' do
-      it 'is not === to instance of subclass of another subclass of deprecated class' do
-        expect(SampleDeprecatedClassB.new.is_a?(SampleDeprecatedClassAX)).to be false
-      end
-
-      it 'is not === to instance of its superclass' do
-        expect(SampleDeprecatedClass.new.is_a?(SampleDeprecatedClassA)).to be false
-      end
-    end
-  end
-
-  def with_warn_squelching
-    stderr_catcher = StringIO.new
-    original_stderr = $stderr
-    $stderr = stderr_catcher
-    result = yield if block_given?
-    [stderr_catcher.tap(&:rewind).string, result]
-  ensure
-    $stderr = original_stderr
-  end
-end

data/spec/faraday/response/middleware_spec.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Response::Middleware do
-  let(:conn) do
-    Faraday.new do |b|
-      b.use custom_middleware
-      b.adapter :test do |stub|
-        stub.get('ok') { [200, { 'Content-Type' => 'text/html' }, '<body></body>'] }
-        stub.get('not_modified') { [304, nil, nil] }
-        stub.get('no_content') { [204, nil, nil] }
-      end
-    end
-  end
-
-  context 'with a custom ResponseMiddleware' do
-    let(:custom_middleware) do
-      Class.new(Faraday::Response::Middleware) do
-        def parse(body)
-          body.upcase
-        end
-      end
-    end
-
-    it 'parses the response' do
-      expect(conn.get('ok').body).to eq('<BODY></BODY>')
-    end
-  end
-
-  context 'with a custom ResponseMiddleware and private parse' do
-    let(:custom_middleware) do
-      Class.new(Faraday::Response::Middleware) do
-        private
-
-        def parse(body)
-          body.upcase
-        end
-      end
-    end
-
-    it 'parses the response' do
-      expect(conn.get('ok').body).to eq('<BODY></BODY>')
-    end
-  end
-
-  context 'with a custom ResponseMiddleware but empty response' do
-    let(:custom_middleware) do
-      Class.new(Faraday::Response::Middleware) do
-        def parse(_body)
-          raise 'this should not be called'
-        end
-      end
-    end
-
-    it 'raises exception for 200 responses' do
-      expect { conn.get('ok') }.to raise_error(StandardError)
-    end
-
-    it 'doesn\'t call the middleware for 204 responses' do
-      expect_any_instance_of(custom_middleware).not_to receive(:parse)
-      expect(conn.get('no_content').body).to be_nil
-    end
-
-    it 'doesn\'t call the middleware for 304 responses' do
-      expect_any_instance_of(custom_middleware).not_to receive(:parse)
-      expect(conn.get('not_modified').body).to be_nil
-    end
-  end
-end

data/spec/support/webmock_rack_app.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-# Rack app used to test the Rack adapter.
-# Uses Webmock to check if requests are registered, in which case it returns
-# the registered response.
-class WebmockRackApp
-  def call(env)
-    req_signature = WebMock::RequestSignature.new(
-      req_method(env),
-      req_uri(env),
-      body: req_body(env),
-      headers: req_headers(env)
-    )
-
-    WebMock::RequestRegistry
-      .instance
-      .requested_signatures
-      .put(req_signature)
-
-    process_response(req_signature)
-  end
-
-  def req_method(env)
-    env['REQUEST_METHOD'].downcase.to_sym
-  end
-
-  def req_uri(env)
-    scheme = env['rack.url_scheme']
-    host = env['SERVER_NAME']
-    port = env['SERVER_PORT']
-    path = env['PATH_INFO']
-    query = env['QUERY_STRING']
-
-    url = +"#{scheme}://#{host}:#{port}#{path}"
-    url += "?#{query}" if query
-
-    uri = WebMock::Util::URI.heuristic_parse(url)
-    uri.path = uri.normalized_path.gsub('[^:]//', '/')
-    uri
-  end
-
-  def req_headers(env)
-    http_headers = env.select { |k, _| k.start_with?('HTTP_') }
-                      .map { |k, v| [k[5..-1], v] }
-                      .to_h
-
-    special_headers = Faraday::Adapter::Rack::SPECIAL_HEADERS
-    http_headers.merge(env.select { |k, _| special_headers.include?(k) })
-  end
-
-  def req_body(env)
-    env['rack.input'].read
-  end
-
-  def process_response(req_signature)
-    res = WebMock::StubRegistry.instance.response_for_request(req_signature)
-
-    if res.nil? && req_signature.uri.host == 'localhost'
-      raise Faraday::ConnectionFailed, 'Trying to connect to localhost'
-    end
-
-    raise WebMock::NetConnectNotAllowedError, req_signature unless res
-
-    raise Faraday::TimeoutError if res.should_timeout
-
-    [res.status[0], res.headers || {}, [res.body || '']]
-  end
-end