faraday 1.5.1 → 1.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05b41e618d412fbb6199856f571098ff152bf81b42839139a2f0527d8f54e6d4
-  data.tar.gz: 5bf7bfe979404c4b58c6030b2348181bfada78c7eca1e352e1eec271b2c490aa
+  metadata.gz: dc552d61adb1522a8fad137e999bf05ca2bab8f23da090e832023a407482e2be
+  data.tar.gz: 90dc970e1e03002fc8f49ca3cd07aeb9636b03b6ebd2fc2fe856c0f38661aa3f
 SHA512:
-  metadata.gz: af7ce1cc0c2a34c6733e2cb655ba2b8fe66729300ee40d9ba0a9161d56ba7e4318ffa4fa754f66d80714732bafe895ec2d2eac717ce62115ee3e3e1979830672
-  data.tar.gz: 3b92a28b2c1172da22f5892d2105e266d3873eb48d07a11090b2b52b5e5bb4a7bacfd8cd15e43b1094ea9df373014d9eb8a1a56226c808440c97489974b249b4
+  metadata.gz: ef70a25de820defbfa52dbc6da6abc01dda7b190326fdf637eaaa3d988b5fefba726ccb3813b974367a7c1a3e00e748dcac44018ba9f2bdd172591dc83441e58
+  data.tar.gz: ddcaf2f3d6bbf55d713a661a429073c4d4230c5723281765e64931cc24a5f17a8ffc81d9cddfc1ca43f759474346993c980797d3978016912a5eb8885677b737

data/examples/client_spec.rb

@@ -12,8 +12,8 @@ class Client
     @conn = conn
   end
 
-  def sushi(jname)
-    res = @conn.get("/#{jname}")
+  def sushi(jname, params: {})
+    res = @conn.get("/#{jname}", params)
     data = JSON.parse(res.body)
     data['name']
   end
@@ -62,4 +62,36 @@ RSpec.describe Client do
     expect { client.sushi('ebi') }.to raise_error(Faraday::ConnectionFailed)
     stubs.verify_stubbed_calls
   end
+
+  context 'When the test stub is run in strict_mode' do
+    let(:stubs) { Faraday::Adapter::Test::Stubs.new(strict_mode: true) }
+
+    it 'verifies the all parameter values are identical' do
+      stubs.get('/ebi?abc=123') do
+        [
+          200,
+          { 'Content-Type': 'application/javascript' },
+          '{"name": "shrimp"}'
+        ]
+      end
+
+      # uncomment to raise Stubs::NotFound
+      # expect(client.sushi('ebi', params: { abc: 123, foo: 'Kappa' })).to eq('shrimp')
+      expect(client.sushi('ebi', params: { abc: 123 })).to eq('shrimp')
+      stubs.verify_stubbed_calls
+    end
+  end
+
+  context 'When the Faraday connection is configured with FlatParamsEncoder' do
+    let(:conn) { Faraday.new(request: { params_encoder: Faraday::FlatParamsEncoder }) { |b| b.adapter(:test, stubs) } }
+
+    it 'handles the same multiple URL parameters' do
+      stubs.get('/ebi?a=x&a=y&a=z') { [200, { 'Content-Type' => 'application/json' }, '{"name": "shrimp"}'] }
+
+      # uncomment to raise Stubs::NotFound
+      # expect(client.sushi('ebi', params: { a: %w[x y] })).to eq('shrimp')
+      expect(client.sushi('ebi', params: { a: %w[x y z] })).to eq('shrimp')
+      stubs.verify_stubbed_calls
+    end
+  end
 end

data/examples/client_test.rb

@@ -13,8 +13,8 @@ class Client
     @conn = conn
   end
 
-  def sushi(jname)
-    res = @conn.get("/#{jname}")
+  def sushi(jname, params: {})
+    res = @conn.get("/#{jname}", params)
     data = JSON.parse(res.body)
     data['name']
   end
@@ -70,6 +70,45 @@ class ClientTest < Test::Unit::TestCase
     stubs.verify_stubbed_calls
   end
 
+  def test_strict_mode
+    stubs = Faraday::Adapter::Test::Stubs.new(strict_mode: true)
+    stubs.get('/ebi?abc=123') do
+      [
+        200,
+        { 'Content-Type': 'application/javascript' },
+        '{"name": "shrimp"}'
+      ]
+    end
+
+    cli = client(stubs)
+    assert_equal 'shrimp', cli.sushi('ebi', params: { abc: 123 })
+
+    # uncomment to raise Stubs::NotFound
+    # assert_equal 'shrimp', cli.sushi('ebi', params: { abc: 123, foo: 'Kappa' })
+    stubs.verify_stubbed_calls
+  end
+
+  def test_non_default_params_encoder
+    stubs = Faraday::Adapter::Test::Stubs.new(strict_mode: true)
+    stubs.get('/ebi?a=x&a=y&a=z') do
+      [
+        200,
+        { 'Content-Type': 'application/javascript' },
+        '{"name": "shrimp"}'
+      ]
+    end
+    conn = Faraday.new(request: { params_encoder: Faraday::FlatParamsEncoder }) do |builder|
+      builder.adapter :test, stubs
+    end
+
+    cli = Client.new(conn)
+    assert_equal 'shrimp', cli.sushi('ebi', params: { a: %w[x y z] })
+
+    # uncomment to raise Stubs::NotFound
+    # assert_equal 'shrimp', cli.sushi('ebi', params: { a: %w[x y] })
+    stubs.verify_stubbed_calls
+  end
+
   def client(stubs)
     conn = Faraday.new do |builder|
       builder.adapter :test, stubs

data/lib/faraday/adapter/test.rb

@@ -25,6 +25,9 @@ module Faraday
     #          "showing item: #{meta[:match_data][1]}"
     #         ]
     #       end
+    #
+    #       # You can set strict_mode to exactly match the stubbed requests.
+    #       stub.strict_mode = true
     #     end
     #   end
     #
@@ -47,10 +50,11 @@ module Faraday
         class NotFound < StandardError
         end
 
-        def initialize
+        def initialize(strict_mode: false)
           # { get: [Stub, Stub] }
           @stack = {}
           @consumed = {}
+          @strict_mode = strict_mode
           yield(self) if block_given?
         end
 
@@ -58,18 +62,20 @@ module Faraday
           @stack.empty?
         end
 
-        def match(request_method, host, path, headers, body)
+        # @param env [Faraday::Env]
+        def match(env)
+          request_method = env[:method]
           return false unless @stack.key?(request_method)
 
           stack = @stack[request_method]
           consumed = (@consumed[request_method] ||= [])
 
-          stub, meta = matches?(stack, host, path, headers, body)
+          stub, meta = matches?(stack, env)
           if stub
             consumed << stack.delete(stub)
             return stub, meta
           end
-          matches?(consumed, host, path, headers, body)
+          matches?(consumed, env)
         end
 
         def get(path, headers = {}, &block)
@@ -115,6 +121,17 @@ module Faraday
           raise failed_stubs.join(' ') unless failed_stubs.empty?
         end
 
+        # Set strict_mode. If the value is true, this adapter tries to find matched requests strictly,
+        # which means that all of a path, parameters, and headers must be the same as an actual request.
+        def strict_mode=(value)
+          @strict_mode = value
+          @stack.each do |_method, stubs|
+            stubs.each do |stub|
+              stub.strict_mode = value
+            end
+          end
+        end
+
         protected
 
         def new_stub(request_method, path, headers = {}, body = nil, &block)
@@ -127,14 +144,18 @@ module Faraday
                 Faraday::Utils.URI(path).host
               ]
             end
+          path, query = normalized_path.respond_to?(:split) ? normalized_path.split('?') : normalized_path
+          headers = Utils::Headers.new(headers)
 
-          stub = Stub.new(host, normalized_path, headers, body, block)
+          stub = Stub.new(host, path, query, headers, body, @strict_mode, block)
           (@stack[request_method] ||= []) << stub
         end
 
-        def matches?(stack, host, path, headers, body)
+        # @param stack [Hash]
+        # @param env [Faraday::Env]
+        def matches?(stack, env)
           stack.each do |stub|
-            match_result, meta = stub.matches?(host, path, headers, body)
+            match_result, meta = stub.matches?(env)
             return stub, meta if match_result
           end
           nil
@@ -142,35 +163,20 @@ module Faraday
       end
 
       # Stub request
-      # rubocop:disable Style/StructInheritance
-      class Stub < Struct.new(:host, :path, :params, :headers, :body, :block)
-        # rubocop:enable Style/StructInheritance
-        def initialize(host, full, headers, body, block)
-          path, query = full.respond_to?(:split) ? full.split('?') : full
-          params =
-            if query
-              Faraday::Utils.parse_nested_query(query)
-            else
-              {}
-            end
-
-          super(host, path, params, headers, body, block)
-        end
+      class Stub < Struct.new(:host, :path, :query, :headers, :body, :strict_mode, :block) # rubocop:disable Style/StructInheritance
+        # @param env [Faraday::Env]
+        def matches?(env)
+          request_host = env[:url].host
+          request_path = Faraday::Utils.normalize_path(env[:url].path)
+          request_headers = env.request_headers
+          request_body = env[:body]
 
-        def matches?(request_host, request_uri, request_headers, request_body)
-          request_path, request_query = request_uri.split('?')
-          request_params =
-            if request_query
-              Faraday::Utils.parse_nested_query(request_query)
-            else
-              {}
-            end
           # meta is a hash used as carrier
           # that will be yielded to consumer block
           meta = {}
           [(host.nil? || host == request_host) &&
             path_match?(request_path, meta) &&
-            params_match?(request_params) &&
+            params_match?(env) &&
             (body.to_s.size.zero? || request_body == body) &&
             headers_match?(request_headers), meta]
         end
@@ -183,13 +189,30 @@ module Faraday
           end
         end
 
-        def params_match?(request_params)
+        # @param env [Faraday::Env]
+        def params_match?(env)
+          request_params = env[:params]
+          params = env.params_encoder.decode(query) || {}
+
+          if strict_mode
+            return Set.new(params) == Set.new(request_params)
+          end
+
           params.keys.all? do |key|
             request_params[key] == params[key]
           end
         end
 
         def headers_match?(request_headers)
+          if strict_mode
+            headers_with_user_agent = headers.dup.tap do |hs|
+              # NOTE: Set User-Agent in case it's not set when creating Stubs.
+              #       Users would not want to set Faraday's User-Agent explicitly.
+              hs[:user_agent] ||= Connection::USER_AGENT
+            end
+            return Set.new(headers_with_user_agent) == Set.new(request_headers)
+          end
+
           headers.keys.all? do |key|
             request_headers[key] == headers[key]
           end
@@ -210,26 +233,19 @@ module Faraday
         yield(stubs)
       end
 
+      # @param env [Faraday::Env]
       def call(env)
         super
-        host = env[:url].host
-        normalized_path = Faraday::Utils.normalize_path(env[:url])
-        params_encoder = env.request.params_encoder ||
-                         Faraday::Utils.default_params_encoder
 
-        stub, meta = stubs.match(env[:method], host, normalized_path,
-                                 env.request_headers, env[:body])
+        env.request.params_encoder ||= Faraday::Utils.default_params_encoder
+        env[:params] = env.params_encoder.decode(env[:url].query) || {}
+        stub, meta = stubs.match(env)
 
         unless stub
           raise Stubs::NotFound, "no stubbed request for #{env[:method]} "\
-                                 "#{normalized_path} #{env[:body]}"
+                                 "#{env[:url]} #{env[:body]}"
         end
 
-        env[:params] = if (query = env[:url].query)
-                         params_encoder.decode(query)
-                       else
-                         {}
-                       end
         block_arity = stub.block.arity
         status, headers, body =
           if block_arity >= 0

data/lib/faraday/adapter.rb

@@ -11,8 +11,7 @@ module Faraday
 
     register_middleware File.expand_path('adapter', __dir__),
                         test: [:Test, 'test'],
-                        typhoeus: [:Typhoeus, 'typhoeus'],
-                        rack: [:Rack, 'rack']
+                        typhoeus: [:Typhoeus, 'typhoeus']
 
     # This module marks an Adapter as supporting parallel requests.
     module Parallelism

data/lib/faraday/autoload.rb

@@ -59,8 +59,7 @@ module Faraday
     extend AutoloadHelper
     autoload_all 'faraday/adapter',
                  Typhoeus: 'typhoeus',
-                 Test: 'test',
-                 Rack: 'rack'
+                 Test: 'test'
   end
 
   # Request represents a single HTTP request for a Faraday adapter to make.

data/lib/faraday/connection.rb

@@ -15,6 +15,7 @@ module Faraday
   class Connection
     # A Set of allowed HTTP verbs.
     METHODS = Set.new %i[get post put delete head patch options trace]
+    USER_AGENT = "Faraday v#{VERSION}"
 
     # @return [Hash] URI query unencoded key/value pairs.
     attr_reader :params
@@ -89,7 +90,7 @@ module Faraday
 
       yield(self) if block_given?
 
-      @headers[:user_agent] ||= "Faraday v#{VERSION}"
+      @headers[:user_agent] ||= USER_AGENT
     end
 
     def initialize_proxy(url, options)
@@ -296,6 +297,11 @@ module Faraday
     #
     # @return [void]
     def basic_auth(login, pass)
+      warn <<~TEXT
+        WARNING: `Faraday::Connection#basic_auth` is deprecated; it will be removed in version 2.0.
+        While initializing your connection, use `#request(:basic_auth, ...)` instead.
+        See https://lostisland.github.io/faraday/middleware/authentication for more usage info.
+      TEXT
       set_authorization_header(:basic_auth, login, pass)
     end
 
@@ -313,6 +319,11 @@ module Faraday
     #
     # @return [void]
     def token_auth(token, options = nil)
+      warn <<~TEXT
+        WARNING: `Faraday::Connection#token_auth` is deprecated; it will be removed in version 2.0.
+        While initializing your connection, use `#request(:token_auth, ...)` instead.
+        See https://lostisland.github.io/faraday/middleware/authentication for more usage info.
+      TEXT
       set_authorization_header(:token_auth, token, options)
     end
 
@@ -335,6 +346,11 @@ module Faraday
     #
     # @return [void]
     def authorization(type, token)
+      warn <<~TEXT
+        WARNING: `Faraday::Connection#authorization` is deprecated; it will be removed in version 2.0.
+        While initializing your connection, use `#request(:authorization, ...)` instead.
+        See https://lostisland.github.io/faraday/middleware/authentication for more usage info.
+      TEXT
       set_authorization_header(:authorization, type, token)
     end
 
@@ -417,13 +433,18 @@ module Faraday
       uri.query = nil
 
       with_uri_credentials(uri) do |user, password|
-        basic_auth user, password
+        set_basic_auth(user, password)
         uri.user = uri.password = nil
       end
 
       @proxy = proxy_from_env(url) unless @manual_proxy
     end
 
+    def set_basic_auth(user, password)
+      header = Faraday::Request::BasicAuthentication.header(user, password)
+      headers[Faraday::Request::Authorization::KEY] = header
+    end
+
     # Sets the path prefix and ensures that it always has a leading
     # slash.
     #

data/lib/faraday/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Faraday
-  VERSION = '1.5.1'
+  VERSION = '1.7.2'
 end

data/lib/faraday.rb

@@ -36,6 +36,7 @@ require 'faraday/httpclient'
 require 'faraday/net_http'
 require 'faraday/net_http_persistent'
 require 'faraday/patron'
+require 'faraday/rack'
 
 # This is the main namespace for Faraday.
 #

data/spec/faraday/adapter/test_spec.rb

@@ -257,4 +257,121 @@ RSpec.describe Faraday::Adapter::Test do
       it { expect { request }.to raise_error described_class::Stubs::NotFound }
     end
   end
+
+  describe 'for request with non default params encoder' do
+    let(:connection) do
+      Faraday.new(request: { params_encoder: Faraday::FlatParamsEncoder }) do |builder|
+        builder.adapter :test, stubs
+      end
+    end
+    let(:stubs) do
+      described_class::Stubs.new do |stubs|
+        stubs.get('/path?a=x&a=y&a=z') { [200, {}, 'a'] }
+      end
+    end
+
+    context 'when all flat param values are correctly set' do
+      subject(:request) { connection.get('/path?a=x&a=y&a=z') }
+
+      it { expect(request.status).to eq 200 }
+    end
+
+    shared_examples 'raise NotFound when params do not satisfy the flat param values' do |params|
+      subject(:request) { connection.get('/path', params) }
+
+      context "with #{params.inspect}" do
+        it { expect { request }.to raise_error described_class::Stubs::NotFound }
+      end
+    end
+
+    it_behaves_like 'raise NotFound when params do not satisfy the flat param values', { a: %w[x] }
+    it_behaves_like 'raise NotFound when params do not satisfy the flat param values', { a: %w[x y] }
+    it_behaves_like 'raise NotFound when params do not satisfy the flat param values', { a: %w[x z y] } # NOTE: The order of the value is also compared.
+    it_behaves_like 'raise NotFound when params do not satisfy the flat param values', { b: %w[x y z] }
+  end
+
+  describe 'strict_mode' do
+    let(:stubs) do
+      described_class::Stubs.new(strict_mode: true) do |stubs|
+        stubs.get('/strict?a=12&b=xy', 'Authorization' => 'Bearer m_ck', 'X-C' => 'hello') { [200, {}, 'a'] }
+        stubs.get('/with_user_agent?a=12&b=xy', authorization: 'Bearer m_ck', 'User-Agent' => 'My Agent') { [200, {}, 'a'] }
+      end
+    end
+
+    context 'when params and headers are exactly set' do
+      subject(:request) { connection.get('/strict', { a: '12', b: 'xy' }, { authorization: 'Bearer m_ck', x_c: 'hello' }) }
+
+      it { expect(request.status).to eq 200 }
+    end
+
+    context 'when params and headers are exactly set with a custom user agent' do
+      subject(:request) { connection.get('/with_user_agent', { a: '12', b: 'xy' }, { authorization: 'Bearer m_ck', 'User-Agent' => 'My Agent' }) }
+
+      it { expect(request.status).to eq 200 }
+    end
+
+    shared_examples 'raise NotFound when params do not satisfy the strict check' do |params|
+      subject(:request) { connection.get('/strict', params, { 'Authorization' => 'Bearer m_ck', 'X-C' => 'hello' }) }
+
+      context "with #{params.inspect}" do
+        it { expect { request }.to raise_error described_class::Stubs::NotFound }
+      end
+    end
+
+    it_behaves_like 'raise NotFound when params do not satisfy the strict check', { a: '12' }
+    it_behaves_like 'raise NotFound when params do not satisfy the strict check', { b: 'xy' }
+    it_behaves_like 'raise NotFound when params do not satisfy the strict check', { a: '123', b: 'xy' }
+    it_behaves_like 'raise NotFound when params do not satisfy the strict check', { a: '12', b: 'xyz' }
+    it_behaves_like 'raise NotFound when params do not satisfy the strict check', { a: '12', b: 'xy', c: 'hello' }
+    it_behaves_like 'raise NotFound when params do not satisfy the strict check', { additional: 'special', a: '12', b: 'xy', c: 'hello' }
+
+    shared_examples 'raise NotFound when headers do not satisfy the strict check' do |path, headers|
+      subject(:request) { connection.get(path, { a: 12, b: 'xy' }, headers) }
+
+      context "with #{headers.inspect}" do
+        it { expect { request }.to raise_error described_class::Stubs::NotFound }
+      end
+    end
+
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/strict', { authorization: 'Bearer m_ck' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/strict', { 'X-C' => 'hello' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/strict', { authorization: 'Bearer m_ck', 'x-c': 'Hi' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/strict', { authorization: 'Basic m_ck', 'x-c': 'hello' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/strict', { authorization: 'Bearer m_ck', 'x-c': 'hello', x_special: 'special' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/with_user_agent', { authorization: 'Bearer m_ck' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/with_user_agent', { authorization: 'Bearer m_ck', user_agent: 'Unknown' }
+    it_behaves_like 'raise NotFound when headers do not satisfy the strict check', '/with_user_agent', { authorization: 'Bearer m_ck', user_agent: 'My Agent', x_special: 'special' }
+
+    context 'when strict_mode is disabled' do
+      before do
+        stubs.strict_mode = false
+      end
+
+      shared_examples 'does not raise NotFound even when params do not satisfy the strict check' do |params|
+        subject(:request) { connection.get('/strict', params, { 'Authorization' => 'Bearer m_ck', 'X-C' => 'hello' }) }
+
+        context "with #{params.inspect}" do
+          it { expect(request.status).to eq 200 }
+        end
+      end
+
+      it_behaves_like 'does not raise NotFound even when params do not satisfy the strict check', { a: '12', b: 'xy' }
+      it_behaves_like 'does not raise NotFound even when params do not satisfy the strict check', { a: '12', b: 'xy', c: 'hello' }
+      it_behaves_like 'does not raise NotFound even when params do not satisfy the strict check', { additional: 'special', a: '12', b: 'xy', c: 'hello' }
+
+      shared_examples 'does not raise NotFound even when headers do not satisfy the strict check' do |path, headers|
+        subject(:request) { connection.get(path, { a: 12, b: 'xy' }, headers) }
+
+        context "with #{headers.inspect}" do
+          it { expect(request.status).to eq 200 }
+        end
+      end
+
+      it_behaves_like 'does not raise NotFound even when headers do not satisfy the strict check', '/strict', { authorization: 'Bearer m_ck', 'x-c': 'hello' }
+      it_behaves_like 'does not raise NotFound even when headers do not satisfy the strict check', '/strict', { authorization: 'Bearer m_ck', 'x-c': 'hello', x_special: 'special' }
+      it_behaves_like 'does not raise NotFound even when headers do not satisfy the strict check', '/strict', { authorization: 'Bearer m_ck', 'x-c': 'hello', user_agent: 'Special Agent' }
+      it_behaves_like 'does not raise NotFound even when headers do not satisfy the strict check', '/with_user_agent', { authorization: 'Bearer m_ck', user_agent: 'My Agent' }
+      it_behaves_like 'does not raise NotFound even when headers do not satisfy the strict check', '/with_user_agent', { authorization: 'Bearer m_ck', user_agent: 'My Agent', x_special: 'special' }
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: faraday
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.7.2
 platform: ruby
 authors:
 - "@technoweenie"
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-11 00:00:00.000000000 Z
+date: 2021-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday-em_http
@@ -110,6 +110,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: multipart-post
   requirement: !ruby/object:Gem::Requirement
@@ -158,7 +172,6 @@ files:
 - examples/client_test.rb
 - lib/faraday.rb
 - lib/faraday/adapter.rb
-- lib/faraday/adapter/rack.rb
 - lib/faraday/adapter/test.rb
 - lib/faraday/adapter/typhoeus.rb
 - lib/faraday/adapter_registry.rb
@@ -247,7 +260,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://lostisland.github.io/faraday
-  changelog_uri: https://github.com/lostisland/faraday/releases/tag/v1.5.1
+  changelog_uri: https://github.com/lostisland/faraday/releases/tag/v1.7.2
   source_code_uri: https://github.com/lostisland/faraday
   bug_tracker_uri: https://github.com/lostisland/faraday/issues
 post_install_message: 

data/lib/faraday/adapter/rack.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Adapter
-    # Sends requests to a Rack app.
-    #
-    # @example
-    #
-    #   class MyRackApp
-    #     def call(env)
-    #       [200, {'Content-Type' => 'text/html'}, ["hello world"]]
-    #     end
-    #   end
-    #
-    #   Faraday.new do |conn|
-    #     conn.adapter :rack, MyRackApp.new
-    #   end
-    class Rack < Faraday::Adapter
-      dependency 'rack/test'
-
-      # not prefixed with "HTTP_"
-      SPECIAL_HEADERS = %w[CONTENT_LENGTH CONTENT_TYPE].freeze
-
-      def initialize(faraday_app, rack_app)
-        super(faraday_app)
-        mock_session = ::Rack::MockSession.new(rack_app)
-        @session     = ::Rack::Test::Session.new(mock_session)
-      end
-
-      def call(env)
-        super
-        rack_env = build_rack_env(env)
-
-        env[:request_headers]&.each do |name, value|
-          name = name.upcase.tr('-', '_')
-          name = "HTTP_#{name}" unless SPECIAL_HEADERS.include? name
-          rack_env[name] = value
-        end
-
-        timeout = request_timeout(:open, env[:request])
-        timeout ||= request_timeout(:read, env[:request])
-        response = if timeout
-                     Timer.timeout(timeout, Faraday::TimeoutError) do
-                       execute_request(env, rack_env)
-                     end
-                   else
-                     execute_request(env, rack_env)
-                   end
-
-        if (req = env[:request]).stream_response?
-          warn "Streaming downloads for #{self.class.name} " \
-            'are not yet implemented.'
-          req.on_data.call(response.body, response.body.bytesize)
-        end
-
-        save_response(env, response.status, response.body, response.headers)
-        @app.call env
-      end
-
-      private
-
-      def execute_request(env, rack_env)
-        @session.request(env[:url].to_s, rack_env)
-      end
-
-      def build_rack_env(env)
-        {
-          method: env[:method],
-          input: env[:body].respond_to?(:read) ? env[:body].read : env[:body],
-          'rack.url_scheme' => env[:url].scheme
-        }
-      end
-    end
-  end
-end