faraday 1.8.0 → 2.0.0.alpha.pre.4

data/spec/faraday/adapter/em_http_spec.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-unless defined?(JRUBY_VERSION)
-  RSpec.describe Faraday::Adapter::EMHttp do
-    features :request_body_on_query_methods, :reason_phrase_parse, :trace_method,
-             :skip_response_body_on_head, :parallel, :local_socket_binding
-
-    it_behaves_like 'an adapter'
-
-    it 'allows to provide adapter specific configs' do
-      url = URI('https://example.com:1234')
-      adapter = described_class.new nil, inactivity_timeout: 20
-      req = adapter.create_request(url: url, request: {})
-
-      expect(req.connopts.inactivity_timeout).to eq(20)
-    end
-
-    context 'Options' do
-      let(:request) { Faraday::RequestOptions.new }
-      let(:env) { { request: request } }
-      let(:options) { {} }
-      let(:adapter) { Faraday::Adapter::EMHttp.new }
-
-      it 'configures timeout' do
-        request.timeout = 5
-        adapter.configure_timeout(options, env)
-        expect(options[:inactivity_timeout]).to eq(5)
-        expect(options[:connect_timeout]).to eq(5)
-      end
-
-      it 'configures timeout and open_timeout' do
-        request.timeout = 5
-        request.open_timeout = 1
-        adapter.configure_timeout(options, env)
-        expect(options[:inactivity_timeout]).to eq(5)
-        expect(options[:connect_timeout]).to eq(1)
-      end
-
-      it 'configures all timeout settings' do
-        request.timeout = 5
-        request.read_timeout = 3
-        request.open_timeout = 1
-        adapter.configure_timeout(options, env)
-        expect(options[:inactivity_timeout]).to eq(3)
-        expect(options[:connect_timeout]).to eq(1)
-      end
-    end
-  end
-end

data/spec/faraday/adapter/em_synchrony_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-unless defined?(JRUBY_VERSION)
-  RSpec.describe Faraday::Adapter::EMSynchrony do
-    features :request_body_on_query_methods, :reason_phrase_parse,
-             :skip_response_body_on_head, :parallel, :local_socket_binding
-
-    it_behaves_like 'an adapter'
-
-    it 'allows to provide adapter specific configs' do
-      url = URI('https://example.com:1234')
-      adapter = described_class.new nil, inactivity_timeout: 20
-      req = adapter.create_request(url: url, request: {})
-
-      expect(req.connopts.inactivity_timeout).to eq(20)
-    end
-  end
-end

data/spec/faraday/adapter/excon_spec.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Adapter::Excon do
-  features :request_body_on_query_methods, :reason_phrase_parse, :trace_method
-
-  it_behaves_like 'an adapter'
-
-  it 'allows to provide adapter specific configs' do
-    url = URI('https://example.com:1234')
-
-    adapter = described_class.new(nil, debug_request: true)
-
-    conn = adapter.build_connection(url: url)
-
-    expect(conn.data[:debug_request]).to be_truthy
-  end
-
-  context 'config' do
-    let(:adapter) { Faraday::Adapter::Excon.new }
-    let(:request) { Faraday::RequestOptions.new }
-    let(:uri) { URI.parse('https://example.com') }
-    let(:env) { { request: request, url: uri } }
-
-    it 'sets timeout' do
-      request.timeout = 5
-      options = adapter.send(:opts_from_env, env)
-      expect(options[:read_timeout]).to eq(5)
-      expect(options[:write_timeout]).to eq(5)
-      expect(options[:connect_timeout]).to eq(5)
-    end
-
-    it 'sets timeout and open_timeout' do
-      request.timeout = 5
-      request.open_timeout = 3
-      options = adapter.send(:opts_from_env, env)
-      expect(options[:read_timeout]).to eq(5)
-      expect(options[:write_timeout]).to eq(5)
-      expect(options[:connect_timeout]).to eq(3)
-    end
-
-    it 'sets open_timeout' do
-      request.open_timeout = 3
-      options = adapter.send(:opts_from_env, env)
-      expect(options[:read_timeout]).to eq(nil)
-      expect(options[:write_timeout]).to eq(nil)
-      expect(options[:connect_timeout]).to eq(3)
-    end
-  end
-end

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/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