faraday 2.15.0 → 2.15.1

data/spec/faraday/rack_builder_spec.rb

@@ -1,323 +0,0 @@
-# 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
-
-  subject { conn.builder }
-  before { Faraday.default_adapter = :test }
-  after { Faraday.default_adapter = nil }
-
-  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 'rejects adapter changes after locking the stack' do
-      conn.get('/')
-      expect { subject.adapter(:net_http) }.to raise_error(Faraday::RackBuilder::StackLocked)
-      expect(subject.adapter).to eq(Faraday::Adapter.lookup_middleware(:test))
-    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 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 '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 adapter is added with named options' do
-    after { Faraday.default_adapter_options = {} }
-    let(:conn) { Faraday::Connection.new {} }
-
-    let(:cat_adapter) do
-      Class.new(Faraday::Adapter) do
-        attr_accessor :name
-
-        def initialize(app, name:)
-          super(app)
-          @name = name
-        end
-      end
-    end
-
-    let(:cat) { subject.adapter.build }
-
-    it 'adds a handler to construct adapter with named options' do
-      Faraday.default_adapter = cat_adapter
-      Faraday.default_adapter_options = { name: 'Chloe' }
-      expect { cat }.to_not output(
-        /warning: Using the last argument as keyword parameters is deprecated/
-      ).to_stderr
-      expect(cat.name).to eq 'Chloe'
-    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 middleware 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 middleware is added with named arguments' do
-    let(:conn) { Faraday::Connection.new {} }
-
-    let(:fish_response) do
-      Class.new(Faraday::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

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Request::Authorization do
-  let(:conn) do
-    Faraday.new do |b|
-      b.request :authorization, 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: 'OAuth oauth_token') }
-
-      it 'does not interfere with existing authorization' do
-        expect(response.body).to eq('OAuth oauth_token')
-      end
-    end
-  end
-
-  let(:response) { conn.get('/auth-echo') }
-
-  describe 'basic_auth' do
-    let(:auth_type) { :basic }
-
-    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 'authorization' do
-    let(:auth_type) { :Bearer }
-
-    context 'when passed a string' do
-      let(:auth_config) { ['custom'] }
-
-      it { expect(response.body).to eq('Bearer custom') }
-
-      include_examples 'does not interfere with existing authentication'
-    end
-
-    context 'when passed a proc' do
-      let(:auth_config) { [-> { 'custom_from_proc' }] }
-
-      it { expect(response.body).to eq('Bearer custom_from_proc') }
-
-      include_examples 'does not interfere with existing authentication'
-    end
-
-    context 'when passed a callable' do
-      let(:callable) { double('Callable Authorizer', call: 'custom_from_callable') }
-      let(:auth_config) { [callable] }
-
-      it { expect(response.body).to eq('Bearer custom_from_callable') }
-
-      include_examples 'does not interfere with existing authentication'
-    end
-
-    context 'with an argument' do
-      let(:response) { conn.get('/auth-echo', nil, 'middle' => 'crunchy surprise') }
-
-      context 'when passed a proc' do
-        let(:auth_config) { [proc { |env| "proc #{env.request_headers['middle']}" }] }
-
-        it { expect(response.body).to eq('Bearer proc crunchy surprise') }
-
-        include_examples 'does not interfere with existing authentication'
-      end
-
-      context 'when passed a lambda' do
-        let(:auth_config) { [->(env) { "lambda #{env.request_headers['middle']}" }] }
-
-        it { expect(response.body).to eq('Bearer lambda crunchy surprise') }
-
-        include_examples 'does not interfere with existing authentication'
-      end
-
-      context 'when passed a callable with an argument' do
-        let(:callable) do
-          Class.new do
-            def call(env)
-              "callable #{env.request_headers['middle']}"
-            end
-          end.new
-        end
-        let(:auth_config) { [callable] }
-
-        it { expect(response.body).to eq('Bearer callable crunchy surprise') }
-
-        include_examples 'does not interfere with existing authentication'
-      end
-    end
-
-    context 'when passed too many arguments' do
-      let(:auth_config) { %w[baz foo] }
-
-      it { expect { response }.to raise_error(ArgumentError) }
-
-      include_examples 'does not interfere with existing authentication'
-    end
-  end
-end

data/spec/faraday/request/instrumentation_spec.rb

@@ -1,74 +0,0 @@
-# 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
-    res = options.instrumenter
-  rescue NameError => e
-    expect(e.to_s).to match('ActiveSupport')
-  else
-    expect(res).to eq(ActiveSupport::Notifications)
-  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

data/spec/faraday/request/json_spec.rb

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Request::Json do
-  let(:middleware) { described_class.new(->(env) { Faraday::Response.new(env) }) }
-
-  def process(body, content_type = nil)
-    env = { body: body, request_headers: Faraday::Utils::Headers.new }
-    env[:request_headers]['content-type'] = content_type if content_type
-    middleware.call(Faraday::Env.from(env)).env
-  end
-
-  def result_body
-    result[:body]
-  end
-
-  def result_type
-    result[:request_headers]['content-type']
-  end
-
-  context 'no body' do
-    let(:result) { process(nil) }
-
-    it "doesn't change body" do
-      expect(result_body).to be_nil
-    end
-
-    it "doesn't add content type" do
-      expect(result_type).to be_nil
-    end
-  end
-
-  context 'empty body' do
-    let(:result) { process('') }
-
-    it "doesn't change body" do
-      expect(result_body).to be_empty
-    end
-
-    it "doesn't add content type" do
-      expect(result_type).to be_nil
-    end
-  end
-
-  context 'string body' do
-    let(:result) { process('{"a":1}') }
-
-    it "doesn't change body" do
-      expect(result_body).to eq('{"a":1}')
-    end
-
-    it 'adds content type' do
-      expect(result_type).to eq('application/json')
-    end
-  end
-
-  context 'object body' do
-    let(:result) { process(a: 1) }
-
-    it 'encodes body' do
-      expect(result_body).to eq('{"a":1}')
-    end
-
-    it 'adds content type' do
-      expect(result_type).to eq('application/json')
-    end
-  end
-
-  context 'empty object body' do
-    let(:result) { process({}) }
-
-    it 'encodes body' do
-      expect(result_body).to eq('{}')
-    end
-  end
-
-  context 'true body' do
-    let(:result) { process(true) }
-
-    it 'encodes body' do
-      expect(result_body).to eq('true')
-    end
-
-    it 'adds content type' do
-      expect(result_type).to eq('application/json')
-    end
-  end
-
-  context 'false body' do
-    let(:result) { process(false) }
-
-    it 'encodes body' do
-      expect(result_body).to eq('false')
-    end
-
-    it 'adds content type' do
-      expect(result_type).to eq('application/json')
-    end
-  end
-
-  context 'object body with json type' do
-    let(:result) { process({ a: 1 }, 'application/json; charset=utf-8') }
-
-    it 'encodes body' do
-      expect(result_body).to eq('{"a":1}')
-    end
-
-    it "doesn't change content type" do
-      expect(result_type).to eq('application/json; charset=utf-8')
-    end
-  end
-
-  context 'object body with vendor json type' do
-    let(:result) { process({ a: 1 }, 'application/vnd.myapp.v1+json; charset=utf-8') }
-
-    it 'encodes body' do
-      expect(result_body).to eq('{"a":1}')
-    end
-
-    it "doesn't change content type" do
-      expect(result_type).to eq('application/vnd.myapp.v1+json; charset=utf-8')
-    end
-  end
-
-  context 'object body with incompatible type' do
-    let(:result) { process({ a: 1 }, 'application/xml; charset=utf-8') }
-
-    it "doesn't change body" do
-      expect(result_body).to eq(a: 1)
-    end
-
-    it "doesn't change content type" do
-      expect(result_type).to eq('application/xml; charset=utf-8')
-    end
-  end
-
-  context 'with encoder' do
-    let(:encoder) do
-      double('Encoder').tap do |e|
-        allow(e).to receive(:dump) { |s, opts| JSON.generate(s, opts) }
-      end
-    end
-
-    let(:result) { process(a: 1) }
-
-    context 'when encoder is passed as object' do
-      let(:middleware) { described_class.new(->(env) { Faraday::Response.new(env) }, { encoder: encoder }) }
-
-      it 'calls specified JSON encoder\'s dump method' do
-        expect(encoder).to receive(:dump).with({ a: 1 })
-
-        result
-      end
-
-      it 'encodes body' do
-        expect(result_body).to eq('{"a":1}')
-      end
-
-      it 'adds content type' do
-        expect(result_type).to eq('application/json')
-      end
-    end
-
-    context 'when encoder is passed as an object-method pair' do
-      let(:middleware) { described_class.new(->(env) { Faraday::Response.new(env) }, { encoder: [encoder, :dump] }) }
-
-      it 'calls specified JSON encoder' do
-        expect(encoder).to receive(:dump).with({ a: 1 })
-
-        result
-      end
-
-      it 'encodes body' do
-        expect(result_body).to eq('{"a":1}')
-      end
-
-      it 'adds content type' do
-        expect(result_type).to eq('application/json')
-      end
-    end
-
-    context 'when encoder is not passed' do
-      let(:middleware) { described_class.new(->(env) { Faraday::Response.new(env) }) }
-
-      it 'calls JSON.generate' do
-        expect(JSON).to receive(:generate).with({ a: 1 })
-
-        result
-      end
-
-      it 'encodes body' do
-        expect(result_body).to eq('{"a":1}')
-      end
-
-      it 'adds content type' do
-        expect(result_type).to eq('application/json')
-      end
-    end
-  end
-end