faraday 1.8.0 → 2.1.0

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/composite_read_io_spec.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require 'stringio'
-
-RSpec.describe Faraday::CompositeReadIO do
-  Part = Struct.new(:to_io) do
-    def length
-      to_io.string.length
-    end
-  end
-
-  def part(str)
-    Part.new StringIO.new(str)
-  end
-
-  def composite_io(*parts)
-    Faraday::CompositeReadIO.new(*parts)
-  end
-
-  context 'with empty composite_io' do
-    subject { composite_io }
-
-    it { expect(subject.length).to eq(0) }
-    it { expect(subject.read).to eq('') }
-    it { expect(subject.read(1)).to be_nil }
-  end
-
-  context 'with empty parts' do
-    subject { composite_io(part(''), part('')) }
-
-    it { expect(subject.length).to eq(0) }
-    it { expect(subject.read).to eq('') }
-    it { expect(subject.read(1)).to be_nil }
-  end
-
-  context 'with 2 parts' do
-    subject { composite_io(part('abcd'), part('1234')) }
-
-    it { expect(subject.length).to eq(8) }
-    it { expect(subject.read).to eq('abcd1234') }
-    it 'allows to read in chunks' do
-      expect(subject.read(3)).to eq('abc')
-      expect(subject.read(3)).to eq('d12')
-      expect(subject.read(3)).to eq('34')
-      expect(subject.read(3)).to be_nil
-    end
-    it 'allows to rewind while reading in chunks' do
-      expect(subject.read(3)).to eq('abc')
-      expect(subject.read(3)).to eq('d12')
-      subject.rewind
-      expect(subject.read(3)).to eq('abc')
-      expect(subject.read(5)).to eq('d1234')
-      expect(subject.read(3)).to be_nil
-      subject.rewind
-      expect(subject.read(2)).to eq('ab')
-    end
-  end
-
-  context 'with mix of empty and non-empty parts' do
-    subject { composite_io(part(''), part('abcd'), part(''), part('1234'), part('')) }
-
-    it 'allows to read in chunks' do
-      expect(subject.read(6)).to eq('abcd12')
-      expect(subject.read(6)).to eq('34')
-      expect(subject.read(6)).to be_nil
-    end
-  end
-
-  context 'with utf8 multibyte part' do
-    subject { composite_io(part("\x86"), part('ファイル')) }
-
-    it { expect(subject.read).to eq(String.new("\x86\xE3\x83\x95\xE3\x82\xA1\xE3\x82\xA4\xE3\x83\xAB", encoding: 'BINARY')) }
-    it 'allows to read in chunks' do
-      expect(subject.read(3)).to eq(String.new("\x86\xE3\x83", encoding: 'BINARY'))
-      expect(subject.read(3)).to eq(String.new("\x95\xE3\x82", encoding: 'BINARY'))
-      expect(subject.read(8)).to eq(String.new("\xA1\xE3\x82\xA4\xE3\x83\xAB", encoding: 'BINARY'))
-      expect(subject.read(3)).to be_nil
-    end
-  end
-end

data/spec/faraday/request/multipart_spec.rb

@@ -1,302 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Request::Multipart do
-  let(:options) { {} }
-  let(:conn) do
-    Faraday.new do |b|
-      b.request :multipart, options
-      b.request :url_encoded
-      b.adapter :test do |stub|
-        stub.post('/echo') do |env|
-          posted_as = env[:request_headers]['Content-Type']
-          expect(env[:body]).to be_a_kind_of(Faraday::CompositeReadIO)
-          [200, { 'Content-Type' => posted_as }, env[:body].read]
-        end
-      end
-    end
-  end
-
-  shared_examples 'a multipart request' do
-    it 'generates a unique boundary for each request' do
-      response1 = conn.post('/echo', payload)
-      response2 = conn.post('/echo', payload)
-
-      b1 = parse_multipart_boundary(response1.headers['Content-Type'])
-      b2 = parse_multipart_boundary(response2.headers['Content-Type'])
-      expect(b1).to_not eq(b2)
-    end
-  end
-
-  context 'FilePart: when multipart objects in param' do
-    let(:payload) do
-      {
-        a: 1,
-        b: {
-          c: Faraday::FilePart.new(__FILE__, 'text/x-ruby', nil,
-                                   'Content-Disposition' => 'form-data; foo=1'),
-          d: 2
-        }
-      }
-    end
-    it_behaves_like 'a multipart request'
-
-    it 'forms a multipart request' do
-      response = conn.post('/echo', payload)
-
-      boundary = parse_multipart_boundary(response.headers['Content-Type'])
-      result = parse_multipart(boundary, response.body)
-      expect(result[:errors]).to be_empty
-
-      part_a, body_a = result.part('a')
-      expect(part_a).to_not be_nil
-      expect(part_a.filename).to be_nil
-      expect(body_a).to eq('1')
-
-      part_bc, body_bc = result.part('b[c]')
-      expect(part_bc).to_not be_nil
-      expect(part_bc.filename).to eq('multipart_spec.rb')
-      expect(part_bc.headers['content-disposition'])
-        .to eq(
-          'form-data; foo=1; name="b[c]"; filename="multipart_spec.rb"'
-        )
-      expect(part_bc.headers['content-type']).to eq('text/x-ruby')
-      expect(part_bc.headers['content-transfer-encoding']).to eq('binary')
-      expect(body_bc).to eq(File.read(__FILE__))
-
-      part_bd, body_bd = result.part('b[d]')
-      expect(part_bd).to_not be_nil
-      expect(part_bd.filename).to be_nil
-      expect(body_bd).to eq('2')
-    end
-  end
-
-  context 'FilePart: when providing json and IO content in the same payload' do
-    let(:io) { StringIO.new('io-content') }
-    let(:json) do
-      {
-        b: 1,
-        c: 2
-      }.to_json
-    end
-
-    let(:payload) do
-      {
-        json: Faraday::ParamPart.new(json, 'application/json'),
-        io: Faraday::FilePart.new(io, 'application/pdf')
-      }
-    end
-
-    it_behaves_like 'a multipart request'
-
-    it 'forms a multipart request' do
-      response = conn.post('/echo', payload)
-
-      boundary = parse_multipart_boundary(response.headers['Content-Type'])
-      result = parse_multipart(boundary, response.body)
-      expect(result[:errors]).to be_empty
-
-      part_json, body_json = result.part('json')
-      expect(part_json).to_not be_nil
-      expect(part_json.mime).to eq('application/json')
-      expect(part_json.filename).to be_nil
-      expect(body_json).to eq(json)
-
-      part_io, body_io = result.part('io')
-      expect(part_io).to_not be_nil
-      expect(part_io.mime).to eq('application/pdf')
-      expect(part_io.filename).to eq('local.path')
-      expect(body_io).to eq(io.string)
-    end
-  end
-
-  context 'FilePart: when multipart objects in array param' do
-    let(:payload) do
-      {
-        a: 1,
-        b: [{
-          c: Faraday::FilePart.new(__FILE__, 'text/x-ruby'),
-          d: 2
-        }]
-      }
-    end
-
-    it_behaves_like 'a multipart request'
-
-    it 'forms a multipart request' do
-      response = conn.post('/echo', payload)
-
-      boundary = parse_multipart_boundary(response.headers['Content-Type'])
-      result = parse_multipart(boundary, response.body)
-      expect(result[:errors]).to be_empty
-
-      part_a, body_a = result.part('a')
-      expect(part_a).to_not be_nil
-      expect(part_a.filename).to be_nil
-      expect(body_a).to eq('1')
-
-      part_bc, body_bc = result.part('b[][c]')
-      expect(part_bc).to_not be_nil
-      expect(part_bc.filename).to eq('multipart_spec.rb')
-      expect(part_bc.headers['content-disposition'])
-        .to eq(
-          'form-data; name="b[][c]"; filename="multipart_spec.rb"'
-        )
-      expect(part_bc.headers['content-type']).to eq('text/x-ruby')
-      expect(part_bc.headers['content-transfer-encoding']).to eq('binary')
-      expect(body_bc).to eq(File.read(__FILE__))
-
-      part_bd, body_bd = result.part('b[][d]')
-      expect(part_bd).to_not be_nil
-      expect(part_bd.filename).to be_nil
-      expect(body_bd).to eq('2')
-    end
-  end
-
-  context 'UploadIO: when multipart objects in param' do
-    let(:payload) do
-      {
-        a: 1,
-        b: {
-          c: Faraday::UploadIO.new(__FILE__, 'text/x-ruby', nil,
-                                   'Content-Disposition' => 'form-data; foo=1'),
-          d: 2
-        }
-      }
-    end
-    it_behaves_like 'a multipart request'
-
-    it 'forms a multipart request' do
-      response = conn.post('/echo', payload)
-
-      boundary = parse_multipart_boundary(response.headers['Content-Type'])
-      result = parse_multipart(boundary, response.body)
-      expect(result[:errors]).to be_empty
-
-      part_a, body_a = result.part('a')
-      expect(part_a).to_not be_nil
-      expect(part_a.filename).to be_nil
-      expect(body_a).to eq('1')
-
-      part_bc, body_bc = result.part('b[c]')
-      expect(part_bc).to_not be_nil
-      expect(part_bc.filename).to eq('multipart_spec.rb')
-      expect(part_bc.headers['content-disposition'])
-        .to eq(
-          'form-data; foo=1; name="b[c]"; filename="multipart_spec.rb"'
-        )
-      expect(part_bc.headers['content-type']).to eq('text/x-ruby')
-      expect(part_bc.headers['content-transfer-encoding']).to eq('binary')
-      expect(body_bc).to eq(File.read(__FILE__))
-
-      part_bd, body_bd = result.part('b[d]')
-      expect(part_bd).to_not be_nil
-      expect(part_bd.filename).to be_nil
-      expect(body_bd).to eq('2')
-    end
-  end
-
-  context 'UploadIO: when providing json and IO content in the same payload' do
-    let(:io) { StringIO.new('io-content') }
-    let(:json) do
-      {
-        b: 1,
-        c: 2
-      }.to_json
-    end
-
-    let(:payload) do
-      {
-        json: Faraday::ParamPart.new(json, 'application/json'),
-        io: Faraday::UploadIO.new(io, 'application/pdf')
-      }
-    end
-
-    it_behaves_like 'a multipart request'
-
-    it 'forms a multipart request' do
-      response = conn.post('/echo', payload)
-
-      boundary = parse_multipart_boundary(response.headers['Content-Type'])
-      result = parse_multipart(boundary, response.body)
-      expect(result[:errors]).to be_empty
-
-      part_json, body_json = result.part('json')
-      expect(part_json).to_not be_nil
-      expect(part_json.mime).to eq('application/json')
-      expect(part_json.filename).to be_nil
-      expect(body_json).to eq(json)
-
-      part_io, body_io = result.part('io')
-      expect(part_io).to_not be_nil
-      expect(part_io.mime).to eq('application/pdf')
-      expect(part_io.filename).to eq('local.path')
-      expect(body_io).to eq(io.string)
-    end
-  end
-
-  context 'UploadIO: when multipart objects in array param' do
-    let(:payload) do
-      {
-        a: 1,
-        b: [{
-          c: Faraday::UploadIO.new(__FILE__, 'text/x-ruby'),
-          d: 2
-        }]
-      }
-    end
-
-    it_behaves_like 'a multipart request'
-
-    it 'forms a multipart request' do
-      response = conn.post('/echo', payload)
-
-      boundary = parse_multipart_boundary(response.headers['Content-Type'])
-      result = parse_multipart(boundary, response.body)
-      expect(result[:errors]).to be_empty
-
-      part_a, body_a = result.part('a')
-      expect(part_a).to_not be_nil
-      expect(part_a.filename).to be_nil
-      expect(body_a).to eq('1')
-
-      part_bc, body_bc = result.part('b[][c]')
-      expect(part_bc).to_not be_nil
-      expect(part_bc.filename).to eq('multipart_spec.rb')
-      expect(part_bc.headers['content-disposition'])
-        .to eq(
-          'form-data; name="b[][c]"; filename="multipart_spec.rb"'
-        )
-      expect(part_bc.headers['content-type']).to eq('text/x-ruby')
-      expect(part_bc.headers['content-transfer-encoding']).to eq('binary')
-      expect(body_bc).to eq(File.read(__FILE__))
-
-      part_bd, body_bd = result.part('b[][d]')
-      expect(part_bd).to_not be_nil
-      expect(part_bd.filename).to be_nil
-      expect(body_bd).to eq('2')
-    end
-  end
-
-  context 'when passing flat_encode=true option' do
-    let(:options) { { flat_encode: true } }
-    let(:io) { StringIO.new('io-content') }
-    let(:payload) do
-      {
-        a: 1,
-        b: [
-          Faraday::UploadIO.new(io, 'application/pdf'),
-          Faraday::UploadIO.new(io, 'application/pdf')
-        ]
-      }
-    end
-
-    it_behaves_like 'a multipart request'
-
-    it 'encode params using flat encoder' do
-      response = conn.post('/echo', payload)
-
-      expect(response.body).to include('name="b"')
-      expect(response.body).not_to include('name="b[]"')
-    end
-  end
-end