RubyGems - faraday - Versions diffs - 0.13.0 → 2.0.0 - Mend

faraday 0.13.0 → 2.0.0

Files changed (92) hide show

checksums.yaml +5 -5
data/CHANGELOG.md +496 -0
data/LICENSE.md +1 -1
data/README.md +28 -328
data/Rakefile +7 -0
data/examples/client_spec.rb +97 -0
data/examples/client_test.rb +118 -0
data/lib/faraday/adapter/test.rb +127 -68
data/lib/faraday/adapter.rb +71 -22
data/lib/faraday/adapter_registry.rb +30 -0
data/lib/faraday/connection.rb +314 -226
data/lib/faraday/encoders/flat_params_encoder.rb +105 -0
data/lib/faraday/encoders/nested_params_encoder.rb +176 -0
data/lib/faraday/error.rb +121 -37
data/lib/faraday/logging/formatter.rb +106 -0
data/lib/faraday/methods.rb +6 -0
data/lib/faraday/middleware.rb +18 -25
data/lib/faraday/middleware_registry.rb +65 -0
data/lib/faraday/options/connection_options.rb +22 -0
data/lib/faraday/options/env.rb +181 -0
data/lib/faraday/options/proxy_options.rb +32 -0
data/lib/faraday/options/request_options.rb +22 -0
data/lib/faraday/options/ssl_options.rb +59 -0
data/lib/faraday/options.rb +41 -195
data/lib/faraday/parameters.rb +4 -196
data/lib/faraday/rack_builder.rb +91 -74
data/lib/faraday/request/authorization.rb +37 -29
data/lib/faraday/request/instrumentation.rb +47 -27
data/lib/faraday/request/json.rb +55 -0
data/lib/faraday/request/url_encoded.rb +45 -23
data/lib/faraday/request.rb +74 -32
data/lib/faraday/response/json.rb +54 -0
data/lib/faraday/response/logger.rb +22 -69
data/lib/faraday/response/raise_error.rb +57 -14
data/lib/faraday/response.rb +26 -33
data/lib/faraday/utils/headers.rb +139 -0
data/lib/faraday/utils/params_hash.rb +61 -0
data/lib/faraday/utils.rb +47 -251
data/lib/faraday/version.rb +5 -0
data/lib/faraday.rb +104 -197
data/spec/external_adapters/faraday_specs_setup.rb +14 -0
data/spec/faraday/adapter/test_spec.rb +377 -0
data/spec/faraday/adapter_registry_spec.rb +28 -0
data/spec/faraday/adapter_spec.rb +55 -0
data/spec/faraday/connection_spec.rb +787 -0
data/spec/faraday/error_spec.rb +60 -0
data/spec/faraday/middleware_spec.rb +52 -0
data/spec/faraday/options/env_spec.rb +70 -0
data/spec/faraday/options/options_spec.rb +297 -0
data/spec/faraday/options/proxy_options_spec.rb +44 -0
data/spec/faraday/options/request_options_spec.rb +19 -0
data/spec/faraday/params_encoders/flat_spec.rb +42 -0
data/spec/faraday/params_encoders/nested_spec.rb +142 -0
data/spec/faraday/rack_builder_spec.rb +302 -0
data/spec/faraday/request/authorization_spec.rb +83 -0
data/spec/faraday/request/instrumentation_spec.rb +74 -0
data/spec/faraday/request/json_spec.rb +111 -0
data/spec/faraday/request/url_encoded_spec.rb +82 -0
data/spec/faraday/request_spec.rb +109 -0
data/spec/faraday/response/json_spec.rb +117 -0
data/spec/faraday/response/logger_spec.rb +220 -0
data/spec/faraday/response/raise_error_spec.rb +172 -0
data/spec/faraday/response_spec.rb +75 -0
data/spec/faraday/utils/headers_spec.rb +82 -0
data/spec/faraday/utils_spec.rb +117 -0
data/spec/faraday_spec.rb +37 -0
data/spec/spec_helper.rb +132 -0
data/spec/support/disabling_stub.rb +14 -0
data/spec/support/fake_safe_buffer.rb +15 -0
data/spec/support/helper_methods.rb +96 -0
data/spec/support/shared_examples/adapter.rb +104 -0
data/spec/support/shared_examples/params_encoder.rb +18 -0
data/spec/support/shared_examples/request_method.rb +249 -0
data/spec/support/streaming_response_checker.rb +35 -0
metadata +71 -34
data/lib/faraday/adapter/em_http.rb +0 -243
data/lib/faraday/adapter/em_http_ssl_patch.rb +0 -56
data/lib/faraday/adapter/em_synchrony/parallel_manager.rb +0 -66
data/lib/faraday/adapter/em_synchrony.rb +0 -106
data/lib/faraday/adapter/excon.rb +0 -80
data/lib/faraday/adapter/httpclient.rb +0 -128
data/lib/faraday/adapter/net_http.rb +0 -135
data/lib/faraday/adapter/net_http_persistent.rb +0 -54
data/lib/faraday/adapter/patron.rb +0 -83
data/lib/faraday/adapter/rack.rb +0 -58
data/lib/faraday/adapter/typhoeus.rb +0 -123
data/lib/faraday/autoload.rb +0 -84
data/lib/faraday/request/basic_authentication.rb +0 -13
data/lib/faraday/request/multipart.rb +0 -68
data/lib/faraday/request/retry.rb +0 -164
data/lib/faraday/request/token_authentication.rb +0 -15
data/lib/faraday/upload_io.rb +0 -67

data/spec/faraday/response/raise_error_spec.rb ADDED Viewed

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+RSpec.describe Faraday::Response::RaiseError do
+  let(:conn) do
+    Faraday.new do |b|
+      b.response :raise_error
+      b.adapter :test do |stub|
+        stub.get('ok') { [200, { 'Content-Type' => 'text/html' }, '<body></body>'] }
+        stub.get('bad-request') { [400, { 'X-Reason' => 'because' }, 'keep looking'] }
+        stub.get('unauthorized') { [401, { 'X-Reason' => 'because' }, 'keep looking'] }
+        stub.get('forbidden') { [403, { 'X-Reason' => 'because' }, 'keep looking'] }
+        stub.get('not-found') { [404, { 'X-Reason' => 'because' }, 'keep looking'] }
+        stub.get('proxy-error') { [407, { 'X-Reason' => 'because' }, 'keep looking'] }
+        stub.get('conflict') { [409, { 'X-Reason' => 'because' }, 'keep looking'] }
+        stub.get('unprocessable-entity') { [422, { 'X-Reason' => 'because' }, 'keep looking'] }
+        stub.get('4xx') { [499, { 'X-Reason' => 'because' }, 'keep looking'] }
+        stub.get('nil-status') { [nil, { 'X-Reason' => 'nil' }, 'fail'] }
+        stub.get('server-error') { [500, { 'X-Error' => 'bailout' }, 'fail'] }
+      end
+    end
+  end
+  it 'raises no exception for 200 responses' do
+    expect { conn.get('ok') }.not_to raise_error
+  end
+  it 'raises Faraday::BadRequestError for 400 responses' do
+    expect { conn.get('bad-request') }.to raise_error(Faraday::BadRequestError) do |ex|
+      expect(ex.message).to eq('the server responded with status 400')
+      expect(ex.response[:headers]['X-Reason']).to eq('because')
+      expect(ex.response[:status]).to eq(400)
+      expect(ex.response_status).to eq(400)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
+    end
+  end
+  it 'raises Faraday::UnauthorizedError for 401 responses' do
+    expect { conn.get('unauthorized') }.to raise_error(Faraday::UnauthorizedError) do |ex|
+      expect(ex.message).to eq('the server responded with status 401')
+      expect(ex.response[:headers]['X-Reason']).to eq('because')
+      expect(ex.response[:status]).to eq(401)
+      expect(ex.response_status).to eq(401)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
+    end
+  end
+  it 'raises Faraday::ForbiddenError for 403 responses' do
+    expect { conn.get('forbidden') }.to raise_error(Faraday::ForbiddenError) do |ex|
+      expect(ex.message).to eq('the server responded with status 403')
+      expect(ex.response[:headers]['X-Reason']).to eq('because')
+      expect(ex.response[:status]).to eq(403)
+      expect(ex.response_status).to eq(403)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
+    end
+  end
+  it 'raises Faraday::ResourceNotFound for 404 responses' do
+    expect { conn.get('not-found') }.to raise_error(Faraday::ResourceNotFound) do |ex|
+      expect(ex.message).to eq('the server responded with status 404')
+      expect(ex.response[:headers]['X-Reason']).to eq('because')
+      expect(ex.response[:status]).to eq(404)
+      expect(ex.response_status).to eq(404)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
+    end
+  end
+  it 'raises Faraday::ProxyAuthError for 407 responses' do
+    expect { conn.get('proxy-error') }.to raise_error(Faraday::ProxyAuthError) do |ex|
+      expect(ex.message).to eq('407 "Proxy Authentication Required"')
+      expect(ex.response[:headers]['X-Reason']).to eq('because')
+      expect(ex.response[:status]).to eq(407)
+      expect(ex.response_status).to eq(407)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
+    end
+  end
+  it 'raises Faraday::ConflictError for 409 responses' do
+    expect { conn.get('conflict') }.to raise_error(Faraday::ConflictError) do |ex|
+      expect(ex.message).to eq('the server responded with status 409')
+      expect(ex.response[:headers]['X-Reason']).to eq('because')
+      expect(ex.response[:status]).to eq(409)
+      expect(ex.response_status).to eq(409)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
+    end
+  end
+  it 'raises Faraday::UnprocessableEntityError for 422 responses' do
+    expect { conn.get('unprocessable-entity') }.to raise_error(Faraday::UnprocessableEntityError) do |ex|
+      expect(ex.message).to eq('the server responded with status 422')
+      expect(ex.response[:headers]['X-Reason']).to eq('because')
+      expect(ex.response[:status]).to eq(422)
+      expect(ex.response_status).to eq(422)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
+    end
+  end
+  it 'raises Faraday::NilStatusError for nil status in response' do
+    expect { conn.get('nil-status') }.to raise_error(Faraday::NilStatusError) do |ex|
+      expect(ex.message).to eq('http status could not be derived from the server response')
+      expect(ex.response[:headers]['X-Reason']).to eq('nil')
+      expect(ex.response[:status]).to be_nil
+      expect(ex.response_status).to be_nil
+      expect(ex.response_body).to eq('fail')
+      expect(ex.response_headers['X-Reason']).to eq('nil')
+    end
+  end
+  it 'raises Faraday::ClientError for other 4xx responses' do
+    expect { conn.get('4xx') }.to raise_error(Faraday::ClientError) do |ex|
+      expect(ex.message).to eq('the server responded with status 499')
+      expect(ex.response[:headers]['X-Reason']).to eq('because')
+      expect(ex.response[:status]).to eq(499)
+      expect(ex.response_status).to eq(499)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
+    end
+  end
+  it 'raises Faraday::ServerError for 500 responses' do
+    expect { conn.get('server-error') }.to raise_error(Faraday::ServerError) do |ex|
+      expect(ex.message).to eq('the server responded with status 500')
+      expect(ex.response[:headers]['X-Error']).to eq('bailout')
+      expect(ex.response[:status]).to eq(500)
+      expect(ex.response_status).to eq(500)
+      expect(ex.response_body).to eq('fail')
+      expect(ex.response_headers['X-Error']).to eq('bailout')
+    end
+  end
+  describe 'request info' do
+    let(:conn) do
+      Faraday.new do |b|
+        b.response :raise_error
+        b.adapter :test do |stub|
+          stub.post(url, request_body, request_headers) do
+            [400, { 'X-Reason' => 'because' }, 'keep looking']
+          end
+        end
+      end
+    end
+    let(:request_body) { JSON.generate({ 'item' => 'sth' }) }
+    let(:request_headers) { { 'Authorization' => 'Basic 123' } }
+    let(:url_path) { 'request' }
+    let(:query_params) { 'full=true' }
+    let(:url) { "#{url_path}?#{query_params}" }
+    subject(:perform_request) do
+      conn.post url do |req|
+        req.headers['Authorization'] = 'Basic 123'
+        req.body = request_body
+      end
+    end
+    it 'returns the request info in the exception' do
+      expect { perform_request }.to raise_error(Faraday::BadRequestError) do |ex|
+        expect(ex.response[:request][:method]).to eq(:post)
+        expect(ex.response[:request][:url]).to eq(URI("http:/#{url}"))
+        expect(ex.response[:request][:url_path]).to eq("/#{url_path}")
+        expect(ex.response[:request][:params]).to eq({ 'full' => 'true' })
+        expect(ex.response[:request][:headers]).to match(a_hash_including(request_headers))
+        expect(ex.response[:request][:body]).to eq(request_body)
+      end
+    end
+  end
+end

data/spec/faraday/response_spec.rb ADDED Viewed

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+RSpec.describe Faraday::Response do
+  subject { Faraday::Response.new(env) }
+  let(:env) do
+    Faraday::Env.from(status: 404, body: 'yikes',
+                      response_headers: { 'Content-Type' => 'text/plain' })
+  end
+  it { expect(subject.finished?).to be_truthy }
+  it { expect { subject.finish({}) }.to raise_error(RuntimeError) }
+  it { expect(subject.success?).to be_falsey }
+  it { expect(subject.status).to eq(404) }
+  it { expect(subject.body).to eq('yikes') }
+  it { expect(subject.headers['Content-Type']).to eq('text/plain') }
+  it { expect(subject['content-type']).to eq('text/plain') }
+  describe '#apply_request' do
+    before { subject.apply_request(body: 'a=b', method: :post) }
+    it { expect(subject.body).to eq('yikes') }
+    it { expect(subject.env[:method]).to eq(:post) }
+  end
+  describe '#to_hash' do
+    let(:hash) { subject.to_hash }
+    it { expect(hash).to be_a(Hash) }
+    it { expect(hash[:status]).to eq(subject.status) }
+    it { expect(hash[:response_headers]).to eq(subject.headers) }
+    it { expect(hash[:body]).to eq(subject.body) }
+  end
+  describe 'marshal serialization support' do
+    subject { Faraday::Response.new }
+    let(:loaded) { Marshal.load(Marshal.dump(subject)) }
+    before do
+      subject.on_complete {}
+      subject.finish(env.merge(params: 'moo'))
+    end
+    it { expect(loaded.env[:params]).to be_nil }
+    it { expect(loaded.env[:body]).to eq(env[:body]) }
+    it { expect(loaded.env[:response_headers]).to eq(env[:response_headers]) }
+    it { expect(loaded.env[:status]).to eq(env[:status]) }
+  end
+  describe '#on_complete' do
+    subject { Faraday::Response.new }
+    it 'parse body on finish' do
+      subject.on_complete { |env| env[:body] = env[:body].upcase }
+      subject.finish(env)
+      expect(subject.body).to eq('YIKES')
+    end
+    it 'can access response body in on_complete callback' do
+      subject.on_complete { |env| env[:body] = subject.body.upcase }
+      subject.finish(env)
+      expect(subject.body).to eq('YIKES')
+    end
+    it 'can access response body in on_complete callback' do
+      callback_env = nil
+      subject.on_complete { |env| callback_env = env }
+      subject.finish({})
+      expect(subject.env).to eq(callback_env)
+    end
+  end
+end

data/spec/faraday/utils/headers_spec.rb ADDED Viewed

@@ -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 ADDED Viewed

@@ -0,0 +1,117 @@
+# 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
+  describe '.deep_merge!' do
+    let(:connection_options) { Faraday::ConnectionOptions.new }
+    let(:url) do
+      {
+        url: 'http://example.com/abc',
+        headers: { 'Mime-Version' => '1.0' },
+        request: { oauth: { consumer_key: 'anonymous' } },
+        ssl: { version: '2' }
+      }
+    end
+    it 'recursively merges the headers' do
+      connection_options.headers = { user_agent: 'My Agent 1.0' }
+      deep_merge = Faraday::Utils.deep_merge!(connection_options, url)
+      expect(deep_merge.headers).to eq('Mime-Version' => '1.0', user_agent: 'My Agent 1.0')
+    end
+    context 'when a target hash has an Options Struct value' do
+      let(:request) do
+        {
+          params_encoder: nil,
+          proxy: nil,
+          bind: nil,
+          timeout: nil,
+          open_timeout: nil,
+          read_timeout: nil,
+          write_timeout: nil,
+          boundary: nil,
+          oauth: { consumer_key: 'anonymous' },
+          context: nil,
+          on_data: nil
+        }
+      end
+      let(:ssl) do
+        {
+          verify: nil,
+          ca_file: nil,
+          ca_path: nil,
+          verify_mode: nil,
+          cert_store: nil,
+          client_cert: nil,
+          client_key: nil,
+          certificate: nil,
+          private_key: nil,
+          verify_depth: nil,
+          version: '2',
+          min_version: nil,
+          max_version: nil
+        }
+      end
+      it 'does not overwrite an Options Struct value' do
+        deep_merge = Faraday::Utils.deep_merge!(connection_options, url)
+        expect(deep_merge.request.to_h).to eq(request)
+        expect(deep_merge.ssl.to_h).to eq(ssl)
+      end
+    end
+  end
+end

data/spec/faraday_spec.rb ADDED Viewed

@@ -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 ADDED Viewed

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+# 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
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# 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
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  # 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
+  # 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"
+  # 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
+  # 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
+  # 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
+  # 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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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, = Regexp.last_match(0), '' =~ /a/ # rubocop:disable Performance/StringInclude
+      yield(match)
+    end
+  end
+end