faraday 0.15.0 → 1.10.0

data/spec/faraday/params_encoders/nested_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'rack/utils'
+
+RSpec.describe Faraday::NestedParamsEncoder do
+  it_behaves_like 'a params encoder'
+
+  it 'decodes arrays' do
+    query    = 'a[1]=one&a[2]=two&a[3]=three'
+    expected = { 'a' => %w[one two three] }
+    expect(subject.decode(query)).to eq(expected)
+  end
+
+  it 'decodes hashes' do
+    query    = 'a[b1]=one&a[b2]=two&a[b][c]=foo'
+    expected = { 'a' => { 'b1' => 'one', 'b2' => 'two', 'b' => { 'c' => 'foo' } } }
+    expect(subject.decode(query)).to eq(expected)
+  end
+
+  it 'decodes nested arrays rack compat' do
+    query    = 'a[][one]=1&a[][two]=2&a[][one]=3&a[][two]=4'
+    expected = Rack::Utils.parse_nested_query(query)
+    expect(subject.decode(query)).to eq(expected)
+  end
+
+  it 'decodes nested array mixed types' do
+    query    = 'a[][one]=1&a[]=2&a[]=&a[]'
+    expected = Rack::Utils.parse_nested_query(query)
+    expect(subject.decode(query)).to eq(expected)
+  end
+
+  it 'decodes nested ignores invalid array' do
+    query    = '[][a]=1&b=2'
+    expected = { 'a' => '1', 'b' => '2' }
+    expect(subject.decode(query)).to eq(expected)
+  end
+
+  it 'decodes nested ignores repeated array notation' do
+    query    = 'a[][][]=1'
+    expected = { 'a' => ['1'] }
+    expect(subject.decode(query)).to eq(expected)
+  end
+
+  it 'decodes nested ignores malformed keys' do
+    query    = '=1&[]=2'
+    expected = {}
+    expect(subject.decode(query)).to eq(expected)
+  end
+
+  it 'decodes nested subkeys dont have to be in brackets' do
+    query    = 'a[b]c[d]e=1'
+    expected = { 'a' => { 'b' => { 'c' => { 'd' => { 'e' => '1' } } } } }
+    expect(subject.decode(query)).to eq(expected)
+  end
+
+  it 'decodes nested final value overrides any type' do
+    query    = 'a[b][c]=1&a[b]=2'
+    expected = { 'a' => { 'b' => '2' } }
+    expect(subject.decode(query)).to eq(expected)
+  end
+
+  it 'encodes rack compat' do
+    params   = { a: [{ one: '1', two: '2' }, '3', ''] }
+    result   = Faraday::Utils.unescape(Faraday::NestedParamsEncoder.encode(params)).split('&')
+    expected = Rack::Utils.build_nested_query(params).split('&')
+    expect(result).to match_array(expected)
+  end
+
+  it 'encodes empty string array value' do
+    expected = 'baz=&foo%5Bbar%5D='
+    result = Faraday::NestedParamsEncoder.encode(foo: { bar: '' }, baz: '')
+    expect(result).to eq(expected)
+  end
+
+  it 'encodes nil array value' do
+    expected = 'baz&foo%5Bbar%5D'
+    result = Faraday::NestedParamsEncoder.encode(foo: { bar: nil }, baz: nil)
+    expect(result).to eq(expected)
+  end
+
+  it 'encodes empty array value' do
+    expected = 'baz%5B%5D&foo%5Bbar%5D%5B%5D'
+    result = Faraday::NestedParamsEncoder.encode(foo: { bar: [] }, baz: [])
+    expect(result).to eq(expected)
+  end
+
+  it 'encodes boolean values' do
+    params = { a: true, b: false }
+    expect(subject.encode(params)).to eq('a=true&b=false')
+  end
+
+  it 'encodes boolean values in array' do
+    params = { a: [true, false] }
+    expect(subject.encode(params)).to eq('a%5B%5D=true&a%5B%5D=false')
+  end
+
+  it 'encodes unsorted when asked' do
+    params = { b: false, a: true }
+    expect(subject.encode(params)).to eq('a=true&b=false')
+    Faraday::NestedParamsEncoder.sort_params = false
+    expect(subject.encode(params)).to eq('b=false&a=true')
+    Faraday::NestedParamsEncoder.sort_params = true
+  end
+
+  shared_examples 'a wrong decoding' do
+    it do
+      expect { subject.decode(query) }.to raise_error(TypeError) do |e|
+        expect(e.message).to eq(error_message)
+      end
+    end
+  end
+
+  context 'when expecting hash but getting string' do
+    let(:query) { 'a=1&a[b]=2' }
+    let(:error_message) { "expected Hash (got String) for param `a'" }
+    it_behaves_like 'a wrong decoding'
+  end
+
+  context 'when expecting hash but getting array' do
+    let(:query) { 'a[]=1&a[b]=2' }
+    let(:error_message) { "expected Hash (got Array) for param `a'" }
+    it_behaves_like 'a wrong decoding'
+  end
+
+  context 'when expecting nested hash but getting non nested' do
+    let(:query) { 'a[b]=1&a[b][c]=2' }
+    let(:error_message) { "expected Hash (got String) for param `b'" }
+    it_behaves_like 'a wrong decoding'
+  end
+
+  context 'when expecting array but getting hash' do
+    let(:query) { 'a[b]=1&a[]=2' }
+    let(:error_message) { "expected Array (got Hash) for param `a'" }
+    it_behaves_like 'a wrong decoding'
+  end
+
+  context 'when expecting array but getting string' do
+    let(:query) { 'a=1&a[]=2' }
+    let(:error_message) { "expected Array (got String) for param `a'" }
+    it_behaves_like 'a wrong decoding'
+  end
+end

data/spec/faraday/rack_builder_spec.rb

@@ -0,0 +1,345 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::RackBuilder do
+  # mock handler classes
+  (Handler = Struct.new(:app)).class_eval do
+    def call(env)
+      env[:request_headers]['X-Middleware'] ||= ''
+      env[:request_headers]['X-Middleware'] += ":#{self.class.name.split('::').last}"
+      app.call(env)
+    end
+  end
+
+  class Apple < Handler
+  end
+  class Orange < Handler
+  end
+  class Banana < Handler
+  end
+
+  class Broken < Faraday::Middleware
+    dependency 'zomg/i_dont/exist'
+  end
+
+  subject { conn.builder }
+
+  context 'with default stack' do
+    let(:conn) { Faraday::Connection.new }
+
+    it { expect(subject[0]).to eq(Faraday::Request.lookup_middleware(:url_encoded)) }
+    it { expect(subject.adapter).to eq(Faraday::Adapter.lookup_middleware(Faraday.default_adapter)) }
+  end
+
+  context 'with custom empty block' do
+    let(:conn) { Faraday::Connection.new {} }
+
+    it { expect(subject[0]).to be_nil }
+    it { expect(subject.adapter).to eq(Faraday::Adapter.lookup_middleware(Faraday.default_adapter)) }
+  end
+
+  context 'with custom adapter only' do
+    let(:conn) do
+      Faraday::Connection.new do |builder|
+        builder.adapter :test do |stub|
+          stub.get('/') { |_| [200, {}, ''] }
+        end
+      end
+    end
+
+    it { expect(subject[0]).to be_nil }
+    it { expect(subject.adapter).to eq(Faraday::Adapter.lookup_middleware(:test)) }
+  end
+
+  context 'with custom handler and adapter' do
+    let(:conn) do
+      Faraday::Connection.new do |builder|
+        builder.use Apple
+        builder.adapter :test do |stub|
+          stub.get('/') { |_| [200, {}, ''] }
+        end
+      end
+    end
+
+    it 'locks the stack after making a request' do
+      expect(subject.locked?).to be_falsey
+      conn.get('/')
+      expect(subject.locked?).to be_truthy
+      expect { subject.use(Orange) }.to raise_error(Faraday::RackBuilder::StackLocked)
+    end
+
+    it 'dup stack is unlocked' do
+      expect(subject.locked?).to be_falsey
+      subject.lock!
+      expect(subject.locked?).to be_truthy
+      dup = subject.dup
+      expect(dup).to eq(subject)
+      expect(dup.locked?).to be_falsey
+    end
+
+    it 'allows to compare handlers' do
+      expect(subject.handlers.first).to eq(Faraday::RackBuilder::Handler.new(Apple))
+    end
+  end
+
+  context 'when having a single handler' do
+    let(:conn) { Faraday::Connection.new {} }
+
+    before { subject.use(Apple) }
+
+    it { expect(subject.handlers).to eq([Apple]) }
+
+    it 'allows rebuilding' do
+      subject.build do |builder|
+        builder.use(Orange)
+      end
+      expect(subject.handlers).to eq([Orange])
+    end
+
+    it 'allows use' do
+      subject.use(Orange)
+      expect(subject.handlers).to eq([Apple, Orange])
+    end
+
+    it 'allows insert_before' do
+      subject.insert_before(Apple, Orange)
+      expect(subject.handlers).to eq([Orange, Apple])
+    end
+
+    it 'allows insert_after' do
+      subject.insert_after(Apple, Orange)
+      expect(subject.handlers).to eq([Apple, Orange])
+    end
+
+    it 'raises an error trying to use an unregistered symbol' do
+      expect { subject.use(:apple) }.to raise_error(Faraday::Error) do |err|
+        expect(err.message).to eq(':apple is not registered on Faraday::Middleware')
+      end
+    end
+  end
+
+  context 'with custom registered middleware' do
+    let(:conn) { Faraday::Connection.new {} }
+
+    after { Faraday::Middleware.unregister_middleware(:apple) }
+
+    it 'allows to register with constant' do
+      Faraday::Middleware.register_middleware(apple: Apple)
+      subject.use(:apple)
+      expect(subject.handlers).to eq([Apple])
+    end
+
+    it 'allows to register with symbol' do
+      Faraday::Middleware.register_middleware(apple: :Apple)
+      subject.use(:apple)
+      expect(subject.handlers).to eq([Apple])
+    end
+
+    it 'allows to register with string' do
+      Faraday::Middleware.register_middleware(apple: 'Apple')
+      subject.use(:apple)
+      expect(subject.handlers).to eq([Apple])
+    end
+
+    it 'allows to register with Proc' do
+      Faraday::Middleware.register_middleware(apple: -> { Apple })
+      subject.use(:apple)
+      expect(subject.handlers).to eq([Apple])
+    end
+  end
+
+  context 'when having two handlers' do
+    let(:conn) { Faraday::Connection.new {} }
+
+    before do
+      subject.use(Apple)
+      subject.use(Orange)
+    end
+
+    it 'allows insert_before' do
+      subject.insert_before(Orange, Banana)
+      expect(subject.handlers).to eq([Apple, Banana, Orange])
+    end
+
+    it 'allows insert_after' do
+      subject.insert_after(Apple, Banana)
+      expect(subject.handlers).to eq([Apple, Banana, Orange])
+    end
+
+    it 'allows to swap handlers' do
+      subject.swap(Apple, Banana)
+      expect(subject.handlers).to eq([Banana, Orange])
+    end
+
+    it 'allows to delete a handler' do
+      subject.delete(Apple)
+      expect(subject.handlers).to eq([Orange])
+    end
+  end
+
+  context 'when having a handler with broken dependency' do
+    let(:conn) do
+      Faraday::Connection.new do |builder|
+        builder.adapter :test do |stub|
+          stub.get('/') { |_| [200, {}, ''] }
+        end
+      end
+    end
+
+    before { subject.use(Broken) }
+
+    it 'raises an error while making a request' do
+      expect { conn.get('/') }.to raise_error(RuntimeError) do |err|
+        expect(err.message).to match(%r{missing dependency for Broken: .+ -- zomg/i_dont/exist})
+      end
+    end
+  end
+
+  context 'when middleware is added with named arguments' do
+    let(:conn) { Faraday::Connection.new {} }
+
+    let(:dog_middleware) do
+      Class.new(Faraday::Middleware) do
+        attr_accessor :name
+
+        def initialize(app, name:)
+          super(app)
+          @name = name
+        end
+      end
+    end
+    let(:dog) do
+      subject.handlers.find { |handler| handler == dog_middleware }.build
+    end
+
+    it 'adds a handler to construct middleware with options passed to use' do
+      subject.use dog_middleware, name: 'Rex'
+      expect { dog }.to_not output(
+        /warning: Using the last argument as keyword parameters is deprecated/
+      ).to_stderr
+      expect(dog.name).to eq('Rex')
+    end
+  end
+
+  context 'when a request adapter is added with named arguments' do
+    let(:conn) { Faraday::Connection.new {} }
+
+    let(:cat_request) do
+      Class.new(Faraday::Middleware) do
+        attr_accessor :name
+
+        def initialize(app, name:)
+          super(app)
+          @name = name
+        end
+      end
+    end
+    let(:cat) do
+      subject.handlers.find { |handler| handler == cat_request }.build
+    end
+
+    it 'adds a handler to construct request adapter with options passed to request' do
+      Faraday::Request.register_middleware cat_request: cat_request
+      subject.request :cat_request, name: 'Felix'
+      expect { cat }.to_not output(
+        /warning: Using the last argument as keyword parameters is deprecated/
+      ).to_stderr
+      expect(cat.name).to eq('Felix')
+    end
+  end
+
+  context 'when a response adapter is added with named arguments' do
+    let(:conn) { Faraday::Connection.new {} }
+
+    let(:fish_response) do
+      Class.new(Faraday::Response::Middleware) do
+        attr_accessor :name
+
+        def initialize(app, name:)
+          super(app)
+          @name = name
+        end
+      end
+    end
+    let(:fish) do
+      subject.handlers.find { |handler| handler == fish_response }.build
+    end
+
+    it 'adds a handler to construct response adapter with options passed to response' do
+      Faraday::Response.register_middleware fish_response: fish_response
+      subject.response :fish_response, name: 'Bubbles'
+      expect { fish }.to_not output(
+        /warning: Using the last argument as keyword parameters is deprecated/
+      ).to_stderr
+      expect(fish.name).to eq('Bubbles')
+    end
+  end
+
+  context 'when a plain adapter is added with named arguments' do
+    let(:conn) { Faraday::Connection.new {} }
+
+    let(:rabbit_adapter) do
+      Class.new(Faraday::Adapter) do
+        attr_accessor :name
+
+        def initialize(app, name:)
+          super(app)
+          @name = name
+        end
+      end
+    end
+    let(:rabbit) do
+      subject.adapter.build
+    end
+
+    it 'adds a handler to construct adapter with options passed to adapter' do
+      Faraday::Adapter.register_middleware rabbit_adapter: rabbit_adapter
+      subject.adapter :rabbit_adapter, name: 'Thumper'
+      expect { rabbit }.to_not output(
+        /warning: Using the last argument as keyword parameters is deprecated/
+      ).to_stderr
+      expect(rabbit.name).to eq('Thumper')
+    end
+  end
+
+  context 'when handlers are directly added or updated' do
+    let(:conn) { Faraday::Connection.new {} }
+
+    let(:rock_handler) do
+      Class.new do
+        attr_accessor :name
+
+        def initialize(_app, name:)
+          @name = name
+        end
+      end
+    end
+    let(:rock) do
+      subject.handlers.find { |handler| handler == rock_handler }.build
+    end
+
+    it 'adds a handler to construct adapter with options passed to insert' do
+      subject.insert 0, rock_handler, name: 'Stony'
+      expect { rock }.to_not output(
+        /warning: Using the last argument as keyword parameters is deprecated/
+      ).to_stderr
+      expect(rock.name).to eq('Stony')
+    end
+
+    it 'adds a handler with options passed to insert_after' do
+      subject.insert_after 0, rock_handler, name: 'Rocky'
+      expect { rock }.to_not output(
+        /warning: Using the last argument as keyword parameters is deprecated/
+      ).to_stderr
+      expect(rock.name).to eq('Rocky')
+    end
+
+    it 'adds a handler with options passed to swap' do
+      subject.insert 0, rock_handler, name: 'Flint'
+      subject.swap 0, rock_handler, name: 'Chert'
+      expect { rock }.to_not output(
+        /warning: Using the last argument as keyword parameters is deprecated/
+      ).to_stderr
+      expect(rock.name).to eq('Chert')
+    end
+  end
+end

data/spec/faraday/request/authorization_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Request::Authorization do
+  let(:conn) do
+    Faraday.new do |b|
+      b.request auth_type, *auth_config
+      b.adapter :test do |stub|
+        stub.get('/auth-echo') do |env|
+          [200, {}, env[:request_headers]['Authorization']]
+        end
+      end
+    end
+  end
+
+  shared_examples 'does not interfere with existing authentication' do
+    context 'and request already has an authentication header' do
+      let(:response) { conn.get('/auth-echo', nil, authorization: 'Token token="bar"') }
+
+      it 'does not interfere with existing authorization' do
+        expect(response.body).to eq('Token token="bar"')
+      end
+    end
+  end
+
+  let(:response) { conn.get('/auth-echo') }
+
+  describe 'basic_auth' do
+    let(:auth_type) { :basic_auth }
+
+    context 'when passed correct params' do
+      let(:auth_config) { %w[aladdin opensesame] }
+
+      it { expect(response.body).to eq('Basic YWxhZGRpbjpvcGVuc2VzYW1l') }
+
+      include_examples 'does not interfere with existing authentication'
+    end
+
+    context 'when passed very long values' do
+      let(:auth_config) { ['A' * 255, ''] }
+
+      it { expect(response.body).to eq("Basic #{'QUFB' * 85}Og==") }
+
+      include_examples 'does not interfere with existing authentication'
+    end
+  end
+
+  describe 'token_auth' do
+    let(:auth_type) { :token_auth }
+
+    context 'when passed correct params' do
+      let(:auth_config) { 'quux' }
+
+      it { expect(response.body).to eq('Token token="quux"') }
+
+      include_examples 'does not interfere with existing authentication'
+    end
+
+    context 'when other values are provided' do
+      let(:auth_config) { ['baz', { foo: 42 }] }
+
+      it { expect(response.body).to match(/^Token /) }
+      it { expect(response.body).to match(/token="baz"/) }
+      it { expect(response.body).to match(/foo="42"/) }
+
+      include_examples 'does not interfere with existing authentication'
+    end
+  end
+
+  describe 'authorization' do
+    let(:auth_type) { :authorization }
+
+    context 'when passed two strings' do
+      let(:auth_config) { ['custom', 'abc def'] }
+
+      it { expect(response.body).to eq('custom abc def') }
+
+      include_examples 'does not interfere with existing authentication'
+    end
+
+    context 'when passed a string and a hash' do
+      let(:auth_config) { ['baz', { foo: 42 }] }
+
+      it { expect(response.body).to eq('baz foo="42"') }
+
+      include_examples 'does not interfere with existing authentication'
+    end
+
+    context 'when passed a string and a proc' do
+      let(:auth_config) { ['Bearer', -> { 'custom_from_proc' }] }
+
+      it { expect(response.body).to eq('Bearer custom_from_proc') }
+
+      include_examples 'does not interfere with existing authentication'
+    end
+  end
+end

data/spec/faraday/request/instrumentation_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Request::Instrumentation do
+  class FakeInstrumenter
+    attr_reader :instrumentations
+
+    def initialize
+      @instrumentations = []
+    end
+
+    def instrument(name, env)
+      @instrumentations << [name, env]
+      yield
+    end
+  end
+
+  let(:config) { {} }
+  let(:options) { Faraday::Request::Instrumentation::Options.from config }
+  let(:instrumenter) { FakeInstrumenter.new }
+  let(:conn) do
+    Faraday.new do |f|
+      f.request :instrumentation, config.merge(instrumenter: instrumenter)
+      f.adapter :test do |stub|
+        stub.get '/' do
+          [200, {}, 'ok']
+        end
+      end
+    end
+  end
+
+  it { expect(options.name).to eq('request.faraday') }
+  it 'defaults to ActiveSupport::Notifications' do
+    begin
+      res = options.instrumenter
+    rescue NameError => e
+      expect(e.to_s).to match('ActiveSupport')
+    else
+      expect(res).to eq(ActiveSupport::Notifications)
+    end
+  end
+
+  it 'instruments with default name' do
+    expect(instrumenter.instrumentations.size).to eq(0)
+
+    res = conn.get '/'
+    expect(res.body).to eq('ok')
+    expect(instrumenter.instrumentations.size).to eq(1)
+
+    name, env = instrumenter.instrumentations.first
+    expect(name).to eq('request.faraday')
+    expect(env[:url].path).to eq('/')
+  end
+
+  context 'with custom name' do
+    let(:config) { { name: 'custom' } }
+
+    it { expect(options.name).to eq('custom') }
+    it 'instruments with custom name' do
+      expect(instrumenter.instrumentations.size).to eq(0)
+
+      res = conn.get '/'
+      expect(res.body).to eq('ok')
+      expect(instrumenter.instrumentations.size).to eq(1)
+
+      name, env = instrumenter.instrumentations.first
+      expect(name).to eq('custom')
+      expect(env[:url].path).to eq('/')
+    end
+  end
+
+  context 'with custom instrumenter' do
+    let(:config) { { instrumenter: :custom } }
+
+    it { expect(options.instrumenter).to eq(:custom) }
+  end
+end