faraday 0.15.0 → 2.2.0

data/spec/faraday/request/json_spec.rb

@@ -0,0 +1,111 @@
+# 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 '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
+end

data/spec/faraday/request/url_encoded_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Request::UrlEncoded do
+  let(:conn) do
+    Faraday.new do |b|
+      b.request :url_encoded
+      b.adapter :test do |stub|
+        stub.post('/echo') do |env|
+          posted_as = env[:request_headers]['Content-Type']
+          [200, { 'Content-Type' => posted_as }, env[:body]]
+        end
+      end
+    end
+  end
+
+  it 'does nothing without payload' do
+    response = conn.post('/echo')
+    expect(response.headers['Content-Type']).to be_nil
+    expect(response.body.empty?).to be_truthy
+  end
+
+  it 'ignores custom content type' do
+    response = conn.post('/echo', { some: 'data' }, 'content-type' => 'application/x-foo')
+    expect(response.headers['Content-Type']).to eq('application/x-foo')
+    expect(response.body).to eq(some: 'data')
+  end
+
+  it 'works with no headers' do
+    response = conn.post('/echo', fruit: %w[apples oranges])
+    expect(response.headers['Content-Type']).to eq('application/x-www-form-urlencoded')
+    expect(response.body).to eq('fruit%5B%5D=apples&fruit%5B%5D=oranges')
+  end
+
+  it 'works with with headers' do
+    response = conn.post('/echo', { 'a' => 123 }, 'content-type' => 'application/x-www-form-urlencoded')
+    expect(response.headers['Content-Type']).to eq('application/x-www-form-urlencoded')
+    expect(response.body).to eq('a=123')
+  end
+
+  it 'works with nested params' do
+    response = conn.post('/echo', user: { name: 'Mislav', web: 'mislav.net' })
+    expect(response.headers['Content-Type']).to eq('application/x-www-form-urlencoded')
+    expected = { 'user' => { 'name' => 'Mislav', 'web' => 'mislav.net' } }
+    expect(Faraday::Utils.parse_nested_query(response.body)).to eq(expected)
+  end
+
+  it 'works with non nested params' do
+    response = conn.post('/echo', dimensions: %w[date location]) do |req|
+      req.options.params_encoder = Faraday::FlatParamsEncoder
+    end
+    expect(response.headers['Content-Type']).to eq('application/x-www-form-urlencoded')
+    expected = { 'dimensions' => %w[date location] }
+    expect(Faraday::Utils.parse_query(response.body)).to eq(expected)
+    expect(response.body).to eq('dimensions=date&dimensions=location')
+  end
+
+  it 'works with unicode' do
+    err = capture_warnings do
+      response = conn.post('/echo', str: 'eé cç aã aâ')
+      expect(response.body).to eq('str=e%C3%A9+c%C3%A7+a%C3%A3+a%C3%A2')
+    end
+    expect(err.empty?).to be_truthy
+  end
+
+  it 'works with nested keys' do
+    response = conn.post('/echo', 'a' => { 'b' => { 'c' => ['d'] } })
+    expect(response.body).to eq('a%5Bb%5D%5Bc%5D%5B%5D=d')
+  end
+
+  context 'customising default_space_encoding' do
+    around do |example|
+      Faraday::Utils.default_space_encoding = '%20'
+      example.run
+      Faraday::Utils.default_space_encoding = nil
+    end
+
+    it 'uses the custom character to encode spaces' do
+      response = conn.post('/echo', str: 'apple banana')
+      expect(response.body).to eq('str=apple%20banana')
+    end
+  end
+end

data/spec/faraday/request_spec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Request do
+  let(:conn) do
+    Faraday.new(url: 'http://httpbingo.org/api',
+                headers: { 'Mime-Version' => '1.0' },
+                request: { oauth: { consumer_key: 'anonymous' } })
+  end
+  let(:http_method) { :get }
+  let(:block) { nil }
+
+  subject { conn.build_request(http_method, &block) }
+
+  context 'when nothing particular is configured' do
+    it { expect(subject.http_method).to eq(:get) }
+    it { expect(subject.to_env(conn).ssl.verify).to be_falsey }
+  end
+
+  context 'when HTTP method is post' do
+    let(:http_method) { :post }
+
+    it { expect(subject.http_method).to eq(:post) }
+  end
+
+  context 'when setting the url on setup with a URI' do
+    let(:block) { proc { |req| req.url URI.parse('foo.json?a=1') } }
+
+    it { expect(subject.path).to eq(URI.parse('foo.json')) }
+    it { expect(subject.params).to eq('a' => '1') }
+    it { expect(subject.to_env(conn).url.to_s).to eq('http://httpbingo.org/api/foo.json?a=1') }
+  end
+
+  context 'when setting the url on setup with a string path and params' do
+    let(:block) { proc { |req| req.url 'foo.json', 'a' => 1 } }
+
+    it { expect(subject.path).to eq('foo.json') }
+    it { expect(subject.params).to eq('a' => 1) }
+    it { expect(subject.to_env(conn).url.to_s).to eq('http://httpbingo.org/api/foo.json?a=1') }
+  end
+
+  context 'when setting the url on setup with a path including params' do
+    let(:block) { proc { |req| req.url 'foo.json?b=2&a=1#qqq' } }
+
+    it { expect(subject.path).to eq('foo.json') }
+    it { expect(subject.params).to eq('a' => '1', 'b' => '2') }
+    it { expect(subject.to_env(conn).url.to_s).to eq('http://httpbingo.org/api/foo.json?a=1&b=2') }
+  end
+
+  context 'when setting a header on setup with []= syntax' do
+    let(:block) { proc { |req| req['Server'] = 'Faraday' } }
+    let(:headers) { subject.to_env(conn).request_headers }
+
+    it { expect(subject.headers['Server']).to eq('Faraday') }
+    it { expect(headers['mime-version']).to eq('1.0') }
+    it { expect(headers['server']).to eq('Faraday') }
+  end
+
+  context 'when setting the body on setup' do
+    let(:block) { proc { |req| req.body = 'hi' } }
+
+    it { expect(subject.body).to eq('hi') }
+    it { expect(subject.to_env(conn).body).to eq('hi') }
+  end
+
+  context 'with global request options set' do
+    let(:env_request) { subject.to_env(conn).request }
+
+    before do
+      conn.options.timeout = 3
+      conn.options.open_timeout = 5
+      conn.ssl.verify = false
+      conn.proxy = 'http://proxy.com'
+    end
+
+    it { expect(subject.options.timeout).to eq(3) }
+    it { expect(subject.options.open_timeout).to eq(5) }
+    it { expect(env_request.timeout).to eq(3) }
+    it { expect(env_request.open_timeout).to eq(5) }
+
+    context 'and per-request options set' do
+      let(:block) do
+        proc do |req|
+          req.options.timeout = 10
+          req.options.boundary = 'boo'
+          req.options.oauth[:consumer_secret] = 'xyz'
+          req.options.context = {
+            foo: 'foo',
+            bar: 'bar'
+          }
+        end
+      end
+
+      it { expect(subject.options.timeout).to eq(10) }
+      it { expect(subject.options.open_timeout).to eq(5) }
+      it { expect(env_request.timeout).to eq(10) }
+      it { expect(env_request.open_timeout).to eq(5) }
+      it { expect(env_request.boundary).to eq('boo') }
+      it { expect(env_request.context).to eq(foo: 'foo', bar: 'bar') }
+      it do
+        oauth_expected = { consumer_secret: 'xyz', consumer_key: 'anonymous' }
+        expect(env_request.oauth).to eq(oauth_expected)
+      end
+    end
+  end
+
+  it 'supports marshal serialization' do
+    expect(Marshal.load(Marshal.dump(subject))).to eq(subject)
+  end
+end

data/spec/faraday/response/json_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Response::Json, type: :response do
+  let(:options) { {} }
+  let(:headers) { {} }
+  let(:middleware) do
+    described_class.new(lambda { |env|
+      Faraday::Response.new(env)
+    }, **options)
+  end
+
+  def process(body, content_type = 'application/json', options = {})
+    env = {
+      body: body, request: options,
+      request_headers: Faraday::Utils::Headers.new,
+      response_headers: Faraday::Utils::Headers.new(headers)
+    }
+    env[:response_headers]['content-type'] = content_type if content_type
+    yield(env) if block_given?
+    middleware.call(Faraday::Env.from(env))
+  end
+
+  context 'no type matching' do
+    it "doesn't change nil body" do
+      expect(process(nil).body).to be_nil
+    end
+
+    it 'nullifies empty body' do
+      expect(process('').body).to be_nil
+    end
+
+    it 'parses json body' do
+      response = process('{"a":1}')
+      expect(response.body).to eq('a' => 1)
+      expect(response.env[:raw_body]).to be_nil
+    end
+  end
+
+  context 'with preserving raw' do
+    let(:options) { { preserve_raw: true } }
+
+    it 'parses json body' do
+      response = process('{"a":1}')
+      expect(response.body).to eq('a' => 1)
+      expect(response.env[:raw_body]).to eq('{"a":1}')
+    end
+  end
+
+  context 'with default regexp type matching' do
+    it 'parses json body of correct type' do
+      response = process('{"a":1}', 'application/x-json')
+      expect(response.body).to eq('a' => 1)
+    end
+
+    it 'ignores json body of incorrect type' do
+      response = process('{"a":1}', 'text/json-xml')
+      expect(response.body).to eq('{"a":1}')
+    end
+  end
+
+  context 'with array type matching' do
+    let(:options) { { content_type: %w[a/b c/d] } }
+
+    it 'parses json body of correct type' do
+      expect(process('{"a":1}', 'a/b').body).to be_a(Hash)
+      expect(process('{"a":1}', 'c/d').body).to be_a(Hash)
+    end
+
+    it 'ignores json body of incorrect type' do
+      expect(process('{"a":1}', 'a/d').body).not_to be_a(Hash)
+    end
+  end
+
+  it 'chokes on invalid json' do
+    expect { process('{!') }.to raise_error(Faraday::ParsingError)
+  end
+
+  it 'includes the response on the ParsingError instance' do
+    process('{') { |env| env[:response] = Faraday::Response.new }
+    raise 'Parsing should have failed.'
+  rescue Faraday::ParsingError => e
+    expect(e.response).to be_a(Faraday::Response)
+  end
+
+  context 'HEAD responses' do
+    it "nullifies the body if it's only one space" do
+      response = process(' ')
+      expect(response.body).to be_nil
+    end
+
+    it "nullifies the body if it's two spaces" do
+      response = process(' ')
+      expect(response.body).to be_nil
+    end
+  end
+
+  context 'JSON options' do
+    let(:body) { '{"a": 1}' }
+    let(:result) { { a: 1 } }
+    let(:options) do
+      {
+        parser_options: {
+          symbolize_names: true
+        }
+      }
+    end
+
+    it 'passes relevant options to JSON parse' do
+      expect(::JSON).to receive(:parse)
+        .with(body, options[:parser_options])
+        .and_return(result)
+
+      response = process(body)
+      expect(response.body).to eq(result)
+    end
+  end
+end

data/spec/faraday/response/logger_spec.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require 'stringio'
+require 'logger'
+
+RSpec.describe Faraday::Response::Logger do
+  let(:string_io) { StringIO.new }
+  let(:logger) { Logger.new(string_io) }
+  let(:logger_options) { {} }
+  let(:conn) do
+    rubbles = ['Barney', 'Betty', 'Bam Bam']
+
+    Faraday.new do |b|
+      b.response :logger, logger, logger_options do |logger|
+        logger.filter(/(soylent green is) (.+)/, '\1 tasty')
+        logger.filter(/(api_key:).*"(.+)."/, '\1[API_KEY]')
+        logger.filter(/(password)=(.+)/, '\1=[HIDDEN]')
+      end
+      b.adapter :test do |stubs|
+        stubs.get('/hello') { [200, { 'Content-Type' => 'text/html' }, 'hello'] }
+        stubs.post('/ohai') { [200, { 'Content-Type' => 'text/html' }, 'fred'] }
+        stubs.post('/ohyes') { [200, { 'Content-Type' => 'text/html' }, 'pebbles'] }
+        stubs.get('/rubbles') { [200, { 'Content-Type' => 'application/json' }, rubbles] }
+        stubs.get('/filtered_body') { [200, { 'Content-Type' => 'text/html' }, 'soylent green is people'] }
+        stubs.get('/filtered_headers') { [200, { 'Content-Type' => 'text/html' }, 'headers response'] }
+        stubs.get('/filtered_params') { [200, { 'Content-Type' => 'text/html' }, 'params response'] }
+        stubs.get('/filtered_url') { [200, { 'Content-Type' => 'text/html' }, 'url response'] }
+      end
+    end
+  end
+
+  before do
+    logger.level = Logger::DEBUG
+  end
+
+  it 'still returns output' do
+    resp = conn.get '/hello', nil, accept: 'text/html'
+    expect(resp.body).to eq('hello')
+  end
+
+  context 'without configuration' do
+    let(:conn) do
+      Faraday.new do |b|
+        b.response :logger
+        b.adapter :test do |stubs|
+          stubs.get('/hello') { [200, { 'Content-Type' => 'text/html' }, 'hello'] }
+        end
+      end
+    end
+
+    it 'defaults to stdout' do
+      expect(Logger).to receive(:new).with($stdout).and_return(Logger.new(nil))
+      conn.get('/hello')
+    end
+  end
+
+  context 'with default formatter' do
+    let(:formatter) { instance_double(Faraday::Logging::Formatter, request: true, response: true, filter: []) }
+
+    before { allow(Faraday::Logging::Formatter).to receive(:new).and_return(formatter) }
+
+    it 'delegates logging to the formatter' do
+      expect(formatter).to receive(:request).with(an_instance_of(Faraday::Env))
+      expect(formatter).to receive(:response).with(an_instance_of(Faraday::Env))
+      conn.get '/hello'
+    end
+  end
+
+  context 'with custom formatter' do
+    let(:formatter_class) do
+      Class.new(Faraday::Logging::Formatter) do
+        def request(_env)
+          info 'Custom log formatter request'
+        end
+
+        def response(_env)
+          info 'Custom log formatter response'
+        end
+      end
+    end
+
+    let(:logger_options) { { formatter: formatter_class } }
+
+    it 'logs with custom formatter' do
+      conn.get '/hello'
+
+      expect(string_io.string).to match('Custom log formatter request')
+      expect(string_io.string).to match('Custom log formatter response')
+    end
+  end
+
+  it 'logs method and url' do
+    conn.get '/hello', nil, accept: 'text/html'
+    expect(string_io.string).to match('GET http:/hello')
+  end
+
+  it 'logs request headers by default' do
+    conn.get '/hello', nil, accept: 'text/html'
+    expect(string_io.string).to match(%(Accept: "text/html))
+  end
+
+  it 'logs response headers by default' do
+    conn.get '/hello', nil, accept: 'text/html'
+    expect(string_io.string).to match(%(Content-Type: "text/html))
+  end
+
+  it 'does not log request body by default' do
+    conn.post '/ohai', 'name=Unagi', accept: 'text/html'
+    expect(string_io.string).not_to match(%(name=Unagi))
+  end
+
+  it 'does not log response body by default' do
+    conn.post '/ohai', 'name=Toro', accept: 'text/html'
+    expect(string_io.string).not_to match(%(fred))
+  end
+
+  it 'logs filter headers' do
+    conn.headers = { 'api_key' => 'ABC123' }
+    conn.get '/filtered_headers', nil, accept: 'text/html'
+    expect(string_io.string).to match(%(api_key:))
+    expect(string_io.string).to match(%([API_KEY]))
+    expect(string_io.string).not_to match(%(ABC123))
+  end
+
+  it 'logs filter url' do
+    conn.get '/filtered_url?password=hunter2', nil, accept: 'text/html'
+    expect(string_io.string).to match(%([HIDDEN]))
+    expect(string_io.string).not_to match(%(hunter2))
+  end
+
+  context 'when not logging request headers' do
+    let(:logger_options) { { headers: { request: false } } }
+
+    it 'does not log request headers if option is false' do
+      conn.get '/hello', nil, accept: 'text/html'
+      expect(string_io.string).not_to match(%(Accept: "text/html))
+    end
+  end
+
+  context 'when not logging response headers' do
+    let(:logger_options) { { headers: { response: false } } }
+
+    it 'does not log response headers if option is false' do
+      conn.get '/hello', nil, accept: 'text/html'
+      expect(string_io.string).not_to match(%(Content-Type: "text/html))
+    end
+  end
+
+  context 'when logging request body' do
+    let(:logger_options) { { bodies: { request: true } } }
+
+    it 'log only request body' do
+      conn.post '/ohyes', 'name=Tamago', accept: 'text/html'
+      expect(string_io.string).to match(%(name=Tamago))
+      expect(string_io.string).not_to match(%(pebbles))
+    end
+  end
+
+  context 'when logging response body' do
+    let(:logger_options) { { bodies: { response: true } } }
+
+    it 'log only response body' do
+      conn.post '/ohyes', 'name=Hamachi', accept: 'text/html'
+      expect(string_io.string).to match(%(pebbles))
+      expect(string_io.string).not_to match(%(name=Hamachi))
+    end
+  end
+
+  context 'when logging request and response bodies' do
+    let(:logger_options) { { bodies: true } }
+
+    it 'log request and response body' do
+      conn.post '/ohyes', 'name=Ebi', accept: 'text/html'
+      expect(string_io.string).to match(%(name=Ebi))
+      expect(string_io.string).to match(%(pebbles))
+    end
+
+    it 'log response body object' do
+      conn.get '/rubbles', nil, accept: 'text/html'
+      expect(string_io.string).to match(%([\"Barney\", \"Betty\", \"Bam Bam\"]\n))
+    end
+
+    it 'logs filter body' do
+      conn.get '/filtered_body', nil, accept: 'text/html'
+      expect(string_io.string).to match(%(soylent green is))
+      expect(string_io.string).to match(%(tasty))
+      expect(string_io.string).not_to match(%(people))
+    end
+  end
+
+  context 'when using log_level' do
+    let(:logger_options) { { bodies: true, log_level: :debug } }
+
+    it 'logs request/request body on the specified level (debug)' do
+      logger.level = Logger::DEBUG
+      conn.post '/ohyes', 'name=Ebi', accept: 'text/html'
+      expect(string_io.string).to match(%(name=Ebi))
+      expect(string_io.string).to match(%(pebbles))
+    end
+
+    it 'logs headers on the debug level' do
+      logger.level = Logger::DEBUG
+      conn.get '/hello', nil, accept: 'text/html'
+      expect(string_io.string).to match(%(Content-Type: "text/html))
+    end
+
+    it 'does not log request/response body on the info level' do
+      logger.level = Logger::INFO
+      conn.post '/ohyes', 'name=Ebi', accept: 'text/html'
+      expect(string_io.string).not_to match(%(name=Ebi))
+      expect(string_io.string).not_to match(%(pebbles))
+    end
+
+    it 'does not log headers on the info level' do
+      logger.level = Logger::INFO
+      conn.get '/hello', nil, accept: 'text/html'
+      expect(string_io.string).not_to match(%(Content-Type: "text/html))
+    end
+  end
+end