faraday 0.17.4 → 1.8.0

data/spec/faraday/utils/headers_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Utils::Headers do
+  subject { Faraday::Utils::Headers.new }
+
+  context 'when Content-Type is set to application/json' do
+    before { subject['Content-Type'] = 'application/json' }
+
+    it { expect(subject.keys).to eq(['Content-Type']) }
+    it { expect(subject['Content-Type']).to eq('application/json') }
+    it { expect(subject['CONTENT-TYPE']).to eq('application/json') }
+    it { expect(subject['content-type']).to eq('application/json') }
+    it { is_expected.to include('content-type') }
+  end
+
+  context 'when Content-Type is set to application/xml' do
+    before { subject['Content-Type'] = 'application/xml' }
+
+    it { expect(subject.keys).to eq(['Content-Type']) }
+    it { expect(subject['Content-Type']).to eq('application/xml') }
+    it { expect(subject['CONTENT-TYPE']).to eq('application/xml') }
+    it { expect(subject['content-type']).to eq('application/xml') }
+    it { is_expected.to include('content-type') }
+  end
+
+  describe '#fetch' do
+    before { subject['Content-Type'] = 'application/json' }
+
+    it { expect(subject.fetch('Content-Type')).to eq('application/json') }
+    it { expect(subject.fetch('CONTENT-TYPE')).to eq('application/json') }
+    it { expect(subject.fetch(:content_type)).to eq('application/json') }
+    it { expect(subject.fetch('invalid', 'default')).to eq('default') }
+    it { expect(subject.fetch('invalid', false)).to eq(false) }
+    it { expect(subject.fetch('invalid', nil)).to be_nil }
+    it { expect(subject.fetch('Invalid') { |key| "#{key} key" }).to eq('Invalid key') }
+    it 'calls a block when provided' do
+      block_called = false
+      expect(subject.fetch('content-type') { block_called = true }).to eq('application/json')
+      expect(block_called).to be_falsey
+    end
+    it 'raises an error if key not found' do
+      expected_error = defined?(KeyError) ? KeyError : IndexError
+      expect { subject.fetch('invalid') }.to raise_error(expected_error)
+    end
+  end
+
+  describe '#delete' do
+    before do
+      subject['Content-Type'] = 'application/json'
+      @deleted = subject.delete('content-type')
+    end
+
+    it { expect(@deleted).to eq('application/json') }
+    it { expect(subject.size).to eq(0) }
+    it { is_expected.not_to include('content-type') }
+    it { expect(subject.delete('content-type')).to be_nil }
+  end
+
+  describe '#parse' do
+    before { subject.parse(headers) }
+
+    context 'when response headers leave http status line out' do
+      let(:headers) { "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n" }
+
+      it { expect(subject.keys).to eq(%w[Content-Type]) }
+      it { expect(subject['Content-Type']).to eq('text/html') }
+      it { expect(subject['content-type']).to eq('text/html') }
+    end
+
+    context 'when response headers values include a colon' do
+      let(:headers) { "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nLocation: http://sushi.com/\r\n\r\n" }
+
+      it { expect(subject['location']).to eq('http://sushi.com/') }
+    end
+
+    context 'when response headers include a blank line' do
+      let(:headers) { "HTTP/1.1 200 OK\r\n\r\nContent-Type: text/html\r\n\r\n" }
+
+      it { expect(subject['content-type']).to eq('text/html') }
+    end
+  end
+end

data/spec/faraday/utils_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Utils do
+  describe 'headers parsing' do
+    let(:multi_response_headers) do
+      "HTTP/1.x 500 OK\r\nContent-Type: text/html; charset=UTF-8\r\n" \
+      "HTTP/1.x 200 OK\r\nContent-Type: application/json; charset=UTF-8\r\n\r\n"
+    end
+
+    it 'parse headers for aggregated responses' do
+      headers = Faraday::Utils::Headers.new
+      headers.parse(multi_response_headers)
+
+      result = headers.to_hash
+
+      expect(result['Content-Type']).to eq('application/json; charset=UTF-8')
+    end
+  end
+
+  describe 'URI parsing' do
+    let(:url) { 'http://example.com/abc' }
+
+    it 'escapes safe buffer' do
+      str = FakeSafeBuffer.new('$32,000.00')
+      expect(Faraday::Utils.escape(str)).to eq('%2432%2C000.00')
+    end
+
+    it 'parses with default parser' do
+      with_default_uri_parser(nil) do
+        uri = normalize(url)
+        expect(uri.host).to eq('example.com')
+      end
+    end
+
+    it 'parses with URI' do
+      with_default_uri_parser(::URI) do
+        uri = normalize(url)
+        expect(uri.host).to eq('example.com')
+      end
+    end
+
+    it 'parses with block' do
+      with_default_uri_parser(->(u) { "booya#{'!' * u.size}" }) do
+        expect(normalize(url)).to eq('booya!!!!!!!!!!!!!!!!!!!!!!')
+      end
+    end
+
+    it 'replaces headers hash' do
+      headers = Faraday::Utils::Headers.new('authorization' => 't0ps3cr3t!')
+      expect(headers).to have_key('authorization')
+
+      headers.replace('content-type' => 'text/plain')
+      expect(headers).not_to have_key('authorization')
+    end
+  end
+end

data/spec/faraday_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday do
+  it 'has a version number' do
+    expect(Faraday::VERSION).not_to be nil
+  end
+
+  context 'proxies to default_connection' do
+    let(:mock_connection) { double('Connection') }
+    before do
+      Faraday.default_connection = mock_connection
+    end
+
+    it 'proxies methods that exist on the default_connection' do
+      expect(mock_connection).to receive(:this_should_be_proxied)
+
+      Faraday.this_should_be_proxied
+    end
+
+    it 'uses method_missing on Faraday if there is no proxyable method' do
+      expect { Faraday.this_method_does_not_exist }.to raise_error(
+        NoMethodError,
+        "undefined method `this_method_does_not_exist' for Faraday:Module"
+      )
+    end
+
+    it 'proxied methods can be accessed' do
+      allow(mock_connection).to receive(:this_should_be_proxied)
+
+      expect(Faraday.method(:this_should_be_proxied)).to be_a(Method)
+    end
+
+    after do
+      Faraday.default_connection = nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'faraday'
-Faraday::Deprecate.skip = false
-
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
 # The generated `.rspec` file contains `--require spec_helper` which will cause
@@ -18,6 +15,29 @@ Faraday::Deprecate.skip = false
 # it.
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'simplecov'
+require 'coveralls'
+require 'webmock/rspec'
+WebMock.disable_net_connect!(allow_localhost: true)
+
+SimpleCov.formatters = [SimpleCov::Formatter::HTMLFormatter, Coveralls::SimpleCov::Formatter]
+
+SimpleCov.start do
+  add_filter '/spec/'
+  minimum_coverage 84
+  minimum_coverage_by_file 26
+end
+
+# Ensure all /lib files are loaded
+# so they will be included in the test coverage report.
+Dir['./lib/**/*.rb'].sort.each { |file| require file }
+
+require 'faraday'
+require 'pry'
+
+Dir['./spec/support/**/*.rb'].sort.each { |f| require f }
+
 RSpec.configure do |config|
   # rspec-expectations config goes here. You can use an alternate
   # assertion/expectation library such as wrong or the stdlib/minitest
@@ -49,57 +69,64 @@ RSpec.configure do |config|
   # triggering implicit auto-inclusion in groups with matching metadata.
   config.shared_context_metadata_behavior = :apply_to_host_groups
 
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = :random
-
-  # Seed global randomization in this process using the `--seed` CLI option.
-  # Setting this allows you to use `--seed` to deterministically reproduce
-  # test failures related to randomization by passing the same `--seed` value
-  # as the one that triggered the failure.
-  Kernel.srand config.seed
-
-  # Limits the available syntax to the non-monkey patched syntax that is
-  # recommended. For more details, see:
-  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
-  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
-  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
-  config.disable_monkey_patching!
-
-# The settings below are suggested to provide a good initial experience
-# with RSpec, but feel free to customize to your heart's content.
-=begin
   # This allows you to limit a spec run to individual examples or groups
   # you care about by tagging them with `:focus` metadata. When nothing
   # is tagged with `:focus`, all examples get run. RSpec also provides
   # aliases for `it`, `describe`, and `context` that include `:focus`
   # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
-  config.filter_run_when_matching :focus
+  # config.filter_run_when_matching :focus
 
   # Allows RSpec to persist some state between runs in order to support
   # the `--only-failures` and `--next-failure` CLI options. We recommend
   # you configure your source control system to ignore this file.
-  config.example_status_persistence_file_path = "spec/examples.txt"
+  # config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  # config.disable_monkey_patching!
 
   # This setting enables warnings. It's recommended, but in some cases may
   # be too noisy due to issues in dependencies.
-  config.warnings = true
+  # config.warnings = true
 
   # Many RSpec users commonly either run the entire suite or an individual
   # file, and it's useful to allow more verbose output when running an
   # individual spec file.
-  if config.files_to_run.one?
-    # Use the documentation formatter for detailed output,
-    # unless a formatter has already been configured
-    # (e.g. via a command-line flag).
-    config.default_formatter = "doc"
-  end
+  # if config.files_to_run.one?
+  #   # Use the documentation formatter for detailed output,
+  #   # unless a formatter has already been configured
+  #   # (e.g. via a command-line flag).
+  #   config.default_formatter = "doc"
+  # end
 
   # Print the 10 slowest examples and example groups at the
   # end of the spec run, to help surface which specs are running
   # particularly slow.
-  config.profile_examples = 10
-=end
+  # config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  config.include Faraday::HelperMethods
+end
+
+# Extends RSpec DocumentationFormatter to hide skipped tests.
+module FormatterOverrides
+  def example_pending(_arg); end
+
+  def dump_pending(_arg); end
+
+  RSpec::Core::Formatters::DocumentationFormatter.prepend self
 end

data/spec/support/disabling_stub.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Allows to disable WebMock stubs
+module DisablingStub
+  def disable
+    @disabled = true
+  end
+
+  def disabled?
+    @disabled
+  end
+
+  WebMock::RequestStub.prepend self
+end

data/spec/support/fake_safe_buffer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# emulates ActiveSupport::SafeBuffer#gsub
+FakeSafeBuffer = Struct.new(:string) do
+  def to_s
+    self
+  end
+
+  def gsub(regex)
+    string.gsub(regex) do
+      match, = $&, '' =~ /a/
+      yield(match)
+    end
+  end
+end

data/spec/support/helper_methods.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'multipart_parser/reader'
+
+module Faraday
+  module HelperMethods
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def features(*features)
+        @features = features
+      end
+
+      def on_feature(name)
+        yield if block_given? && feature?(name)
+      end
+
+      def feature?(name)
+        if @features.nil?
+          superclass.feature?(name) if superclass.respond_to?(:feature?)
+        elsif @features.include?(name)
+          true
+        end
+      end
+
+      def method_with_body?(method)
+        METHODS_WITH_BODY.include?(method.to_s)
+      end
+    end
+
+    def ssl_mode?
+      ENV['SSL'] == 'yes'
+    end
+
+    def normalize(url)
+      Faraday::Utils::URI(url)
+    end
+
+    def with_default_uri_parser(parser)
+      old_parser = Faraday::Utils.default_uri_parser
+      begin
+        Faraday::Utils.default_uri_parser = parser
+        yield
+      ensure
+        Faraday::Utils.default_uri_parser = old_parser
+      end
+    end
+
+    def with_env(new_env)
+      old_env = {}
+
+      new_env.each do |key, value|
+        old_env[key] = ENV.fetch(key, false)
+        ENV[key] = value
+      end
+
+      begin
+        yield
+      ensure
+        old_env.each do |key, value|
+          value == false ? ENV.delete(key) : ENV[key] = value
+        end
+      end
+    end
+
+    def with_env_proxy_disabled
+      Faraday.ignore_env_proxy = true
+
+      begin
+        yield
+      ensure
+        Faraday.ignore_env_proxy = false
+      end
+    end
+
+    def capture_warnings
+      old = $stderr
+      $stderr = StringIO.new
+      begin
+        yield
+        $stderr.string
+      ensure
+        $stderr = old
+      end
+    end
+
+    def multipart_file
+      Faraday::FilePart.new(__FILE__, 'text/x-ruby')
+    end
+
+    # parse boundary out of a Content-Type header like:
+    #   Content-Type: multipart/form-data; boundary=gc0p4Jq0M2Yt08jU534c0p
+    def parse_multipart_boundary(ctype)
+      MultipartParser::Reader.extract_boundary_value(ctype)
+    end
+
+    # parse a multipart MIME message, returning a hash of any multipart errors
+    def parse_multipart(boundary, body)
+      reader = MultipartParser::Reader.new(boundary)
+      result = { errors: [], parts: [] }
+      def result.part(name)
+        hash = self[:parts].detect { |h| h[:part].name == name }
+        [hash[:part], hash[:body].join]
+      end
+
+      reader.on_part do |part|
+        result[:parts] << thispart = {
+          part: part,
+          body: []
+        }
+        part.on_data do |chunk|
+          thispart[:body] << chunk
+        end
+      end
+      reader.on_error do |msg|
+        result[:errors] << msg
+      end
+      reader.write(body)
+      result
+    end
+
+    def method_with_body?(method)
+      self.class.method_with_body?(method)
+    end
+
+    def big_string
+      kb = 1024
+      (32..126).map(&:chr).cycle.take(50 * kb).join
+    end
+  end
+end

data/spec/support/shared_examples/adapter.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+shared_examples 'an adapter' do |**options|
+  before { skip } if options[:skip]
+
+  context 'with SSL enabled' do
+    before { ENV['SSL'] = 'yes' }
+    include_examples 'adapter examples', options
+  end
+
+  context 'with SSL disabled' do
+    before { ENV['SSL'] = 'no' }
+    include_examples 'adapter examples', options
+  end
+end
+
+shared_examples 'adapter examples' do |**options|
+  include Faraday::StreamingResponseChecker
+
+  let(:adapter) { described_class.name.split('::').last }
+
+  let(:conn_options) { { headers: { 'X-Faraday-Adapter' => adapter } }.merge(options[:conn_options] || {}) }
+
+  let(:adapter_options) do
+    return [] unless options[:adapter_options]
+
+    if options[:adapter_options].is_a?(Array)
+      options[:adapter_options]
+    else
+      [options[:adapter_options]]
+    end
+  end
+
+  let(:protocol) { ssl_mode? ? 'https' : 'http' }
+  let(:remote) { "#{protocol}://example.com" }
+  let(:stub_remote) { remote }
+
+  let(:conn) do
+    conn_options[:ssl] ||= {}
+    conn_options[:ssl][:ca_file] ||= ENV['SSL_FILE']
+
+    Faraday.new(remote, conn_options) do |conn|
+      conn.request :multipart
+      conn.request :url_encoded
+      conn.response :raise_error
+      conn.adapter described_class, *adapter_options
+    end
+  end
+
+  let!(:request_stub) { stub_request(http_method, stub_remote) }
+
+  after do
+    expect(request_stub).to have_been_requested unless request_stub.disabled?
+  end
+
+  describe '#delete' do
+    let(:http_method) { :delete }
+
+    it_behaves_like 'a request method', :delete
+  end
+
+  describe '#get' do
+    let(:http_method) { :get }
+
+    it_behaves_like 'a request method', :get
+  end
+
+  describe '#head' do
+    let(:http_method) { :head }
+
+    it_behaves_like 'a request method', :head
+  end
+
+  describe '#options' do
+    let(:http_method) { :options }
+
+    it_behaves_like 'a request method', :options
+  end
+
+  describe '#patch' do
+    let(:http_method) { :patch }
+
+    it_behaves_like 'a request method', :patch
+  end
+
+  describe '#post' do
+    let(:http_method) { :post }
+
+    it_behaves_like 'a request method', :post
+  end
+
+  describe '#put' do
+    let(:http_method) { :put }
+
+    it_behaves_like 'a request method', :put
+  end
+
+  on_feature :trace_method do
+    describe '#trace' do
+      let(:http_method) { :trace }
+
+      it_behaves_like 'a request method', :trace
+    end
+  end
+end

data/spec/support/shared_examples/params_encoder.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+shared_examples 'a params encoder' do
+  it 'escapes safe buffer' do
+    monies = FakeSafeBuffer.new('$32,000.00')
+    expect(subject.encode('a' => monies)).to eq('a=%2432%2C000.00')
+  end
+
+  it 'raises type error for empty string' do
+    expect { subject.encode('') }.to raise_error(TypeError) do |error|
+      expect(error.message).to eq("Can't convert String into Hash.")
+    end
+  end
+
+  it 'encodes nil' do
+    expect(subject.encode('a' => nil)).to eq('a')
+  end
+end