faraday 1.10.6 → 2.0.0.alpha.pre.1

data/spec/faraday/rack_builder_spec.rb

@@ -12,13 +12,11 @@ RSpec.describe Faraday::RackBuilder do
 
   class Apple < Handler
   end
+
   class Orange < Handler
   end
-  class Banana < Handler
-  end
 
-  class Broken < Faraday::Middleware
-    dependency 'zomg/i_dont/exist'
+  class Banana < Handler
   end
 
   subject { conn.builder }
@@ -127,24 +125,6 @@ RSpec.describe Faraday::RackBuilder do
       subject.use(:apple)
       expect(subject.handlers).to eq([Apple])
     end
-
-    it 'allows to register with symbol' do
-      Faraday::Middleware.register_middleware(apple: :Apple)
-      subject.use(:apple)
-      expect(subject.handlers).to eq([Apple])
-    end
-
-    it 'allows to register with string' do
-      Faraday::Middleware.register_middleware(apple: 'Apple')
-      subject.use(:apple)
-      expect(subject.handlers).to eq([Apple])
-    end
-
-    it 'allows to register with Proc' do
-      Faraday::Middleware.register_middleware(apple: -> { Apple })
-      subject.use(:apple)
-      expect(subject.handlers).to eq([Apple])
-    end
   end
 
   context 'when having two handlers' do
@@ -176,24 +156,6 @@ RSpec.describe Faraday::RackBuilder do
     end
   end
 
-  context 'when having a handler with broken dependency' do
-    let(:conn) do
-      Faraday::Connection.new do |builder|
-        builder.adapter :test do |stub|
-          stub.get('/') { |_| [200, {}, ''] }
-        end
-      end
-    end
-
-    before { subject.use(Broken) }
-
-    it 'raises an error while making a request' do
-      expect { conn.get('/') }.to raise_error(RuntimeError) do |err|
-        expect(err.message).to match(%r{missing dependency for Broken: .+ -- zomg/i_dont/exist})
-      end
-    end
-  end
-
   context 'when middleware is added with named arguments' do
     let(:conn) { Faraday::Connection.new {} }
 
@@ -220,7 +182,7 @@ RSpec.describe Faraday::RackBuilder do
     end
   end
 
-  context 'when a request adapter is added with named arguments' do
+  context 'when a middleware is added with named arguments' do
     let(:conn) { Faraday::Connection.new {} }
 
     let(:cat_request) do
@@ -247,11 +209,11 @@ RSpec.describe Faraday::RackBuilder do
     end
   end
 
-  context 'when a response adapter is added with named arguments' do
+  context 'when a middleware is added with named arguments' do
     let(:conn) { Faraday::Connection.new {} }
 
     let(:fish_response) do
-      Class.new(Faraday::Response::Middleware) do
+      Class.new(Faraday::Middleware) do
         attr_accessor :name
 
         def initialize(app, name:)

data/spec/faraday/request/authorization_spec.rb

@@ -3,7 +3,7 @@
 RSpec.describe Faraday::Request::Authorization do
   let(:conn) do
     Faraday.new do |b|
-      b.request auth_type, *auth_config
+      b.request :authorization, auth_type, *auth_config
       b.adapter :test do |stub|
         stub.get('/auth-echo') do |env|
           [200, {}, env[:request_headers]['Authorization']]
@@ -14,10 +14,10 @@ RSpec.describe Faraday::Request::Authorization do
 
   shared_examples 'does not interfere with existing authentication' do
     context 'and request already has an authentication header' do
-      let(:response) { conn.get('/auth-echo', nil, authorization: 'Token token="bar"') }
+      let(:response) { conn.get('/auth-echo', nil, authorization: 'OAuth oauth_token') }
 
       it 'does not interfere with existing authorization' do
-        expect(response.body).to eq('Token token="bar"')
+        expect(response.body).to eq('OAuth oauth_token')
       end
     end
   end
@@ -25,7 +25,7 @@ RSpec.describe Faraday::Request::Authorization do
   let(:response) { conn.get('/auth-echo') }
 
   describe 'basic_auth' do
-    let(:auth_type) { :basic_auth }
+    let(:auth_type) { :basic }
 
     context 'when passed correct params' do
       let(:auth_config) { %w[aladdin opensesame] }
@@ -44,51 +44,29 @@ RSpec.describe Faraday::Request::Authorization do
     end
   end
 
-  describe 'token_auth' do
-    let(:auth_type) { :token_auth }
-
-    context 'when passed correct params' do
-      let(:auth_config) { 'quux' }
-
-      it { expect(response.body).to eq('Token token="quux"') }
-
-      include_examples 'does not interfere with existing authentication'
-    end
-
-    context 'when other values are provided' do
-      let(:auth_config) { ['baz', { foo: 42 }] }
-
-      it { expect(response.body).to match(/^Token /) }
-      it { expect(response.body).to match(/token="baz"/) }
-      it { expect(response.body).to match(/foo="42"/) }
-
-      include_examples 'does not interfere with existing authentication'
-    end
-  end
-
   describe 'authorization' do
-    let(:auth_type) { :authorization }
+    let(:auth_type) { :Bearer }
 
-    context 'when passed two strings' do
-      let(:auth_config) { ['custom', 'abc def'] }
+    context 'when passed a string' do
+      let(:auth_config) { ['custom'] }
 
-      it { expect(response.body).to eq('custom abc def') }
+      it { expect(response.body).to eq('Bearer custom') }
 
       include_examples 'does not interfere with existing authentication'
     end
 
-    context 'when passed a string and a hash' do
-      let(:auth_config) { ['baz', { foo: 42 }] }
+    context 'when passed a proc' do
+      let(:auth_config) { [-> { 'custom_from_proc' }] }
 
-      it { expect(response.body).to eq('baz foo="42"') }
+      it { expect(response.body).to eq('Bearer custom_from_proc') }
 
       include_examples 'does not interfere with existing authentication'
     end
 
-    context 'when passed a string and a proc' do
-      let(:auth_config) { ['Bearer', -> { 'custom_from_proc' }] }
+    context 'when passed too many arguments' do
+      let(:auth_config) { %w[baz foo] }
 
-      it { expect(response.body).to eq('Bearer custom_from_proc') }
+      it { expect { response }.to raise_error(ArgumentError) }
 
       include_examples 'does not interfere with existing authentication'
     end

data/spec/faraday/request/instrumentation_spec.rb

@@ -30,13 +30,11 @@ RSpec.describe Faraday::Request::Instrumentation do
 
   it { expect(options.name).to eq('request.faraday') }
   it 'defaults to ActiveSupport::Notifications' do
-    begin
-      res = options.instrumenter
-    rescue NameError => e
-      expect(e.to_s).to match('ActiveSupport')
-    else
-      expect(res).to eq(ActiveSupport::Notifications)
-    end
+    res = options.instrumenter
+  rescue NameError => e
+    expect(e.to_s).to match('ActiveSupport')
+  else
+    expect(res).to eq(ActiveSupport::Notifications)
   end
 
   it 'instruments with default name' do

data/spec/faraday/request/multipart_spec.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Request::Multipart do
+  let(:options) { {} }
+  let(:conn) do
+    Faraday.new do |b|
+      b.request :multipart, options
+      b.request :url_encoded
+      b.adapter :test do |stub|
+        stub.post('/echo') do |env|
+          posted_as = env[:request_headers]['Content-Type']
+          expect(env[:body]).to be_a_kind_of(Faraday::CompositeReadIO)
+          [200, { 'Content-Type' => posted_as }, env[:body].read]
+        end
+      end
+    end
+  end
+
+  shared_examples 'a multipart request' do
+    it 'generates a unique boundary for each request' do
+      response1 = conn.post('/echo', payload)
+      response2 = conn.post('/echo', payload)
+
+      b1 = parse_multipart_boundary(response1.headers['Content-Type'])
+      b2 = parse_multipart_boundary(response2.headers['Content-Type'])
+      expect(b1).to_not eq(b2)
+    end
+  end
+
+  context 'FilePart: when multipart objects in param' do
+    let(:payload) do
+      {
+        a: 1,
+        b: {
+          c: Faraday::FilePart.new(__FILE__, 'text/x-ruby', nil,
+                                   'Content-Disposition' => 'form-data; foo=1'),
+          d: 2
+        }
+      }
+    end
+    it_behaves_like 'a multipart request'
+
+    it 'forms a multipart request' do
+      response = conn.post('/echo', payload)
+
+      boundary = parse_multipart_boundary(response.headers['Content-Type'])
+      result = parse_multipart(boundary, response.body)
+      expect(result[:errors]).to be_empty
+
+      part_a, body_a = result.part('a')
+      expect(part_a).to_not be_nil
+      expect(part_a.filename).to be_nil
+      expect(body_a).to eq('1')
+
+      part_bc, body_bc = result.part('b[c]')
+      expect(part_bc).to_not be_nil
+      expect(part_bc.filename).to eq('multipart_spec.rb')
+      expect(part_bc.headers['content-disposition'])
+        .to eq(
+          'form-data; foo=1; name="b[c]"; filename="multipart_spec.rb"'
+        )
+      expect(part_bc.headers['content-type']).to eq('text/x-ruby')
+      expect(part_bc.headers['content-transfer-encoding']).to eq('binary')
+      expect(body_bc).to eq(File.read(__FILE__))
+
+      part_bd, body_bd = result.part('b[d]')
+      expect(part_bd).to_not be_nil
+      expect(part_bd.filename).to be_nil
+      expect(body_bd).to eq('2')
+    end
+  end
+
+  context 'FilePart: when providing json and IO content in the same payload' do
+    let(:io) { StringIO.new('io-content') }
+    let(:json) do
+      {
+        b: 1,
+        c: 2
+      }.to_json
+    end
+
+    let(:payload) do
+      {
+        json: Faraday::ParamPart.new(json, 'application/json'),
+        io: Faraday::FilePart.new(io, 'application/pdf')
+      }
+    end
+
+    it_behaves_like 'a multipart request'
+
+    it 'forms a multipart request' do
+      response = conn.post('/echo', payload)
+
+      boundary = parse_multipart_boundary(response.headers['Content-Type'])
+      result = parse_multipart(boundary, response.body)
+      expect(result[:errors]).to be_empty
+
+      part_json, body_json = result.part('json')
+      expect(part_json).to_not be_nil
+      expect(part_json.mime).to eq('application/json')
+      expect(part_json.filename).to be_nil
+      expect(body_json).to eq(json)
+
+      part_io, body_io = result.part('io')
+      expect(part_io).to_not be_nil
+      expect(part_io.mime).to eq('application/pdf')
+      expect(part_io.filename).to eq('local.path')
+      expect(body_io).to eq(io.string)
+    end
+  end
+
+  context 'FilePart: when multipart objects in array param' do
+    let(:payload) do
+      {
+        a: 1,
+        b: [{
+          c: Faraday::FilePart.new(__FILE__, 'text/x-ruby'),
+          d: 2
+        }]
+      }
+    end
+
+    it_behaves_like 'a multipart request'
+
+    it 'forms a multipart request' do
+      response = conn.post('/echo', payload)
+
+      boundary = parse_multipart_boundary(response.headers['Content-Type'])
+      result = parse_multipart(boundary, response.body)
+      expect(result[:errors]).to be_empty
+
+      part_a, body_a = result.part('a')
+      expect(part_a).to_not be_nil
+      expect(part_a.filename).to be_nil
+      expect(body_a).to eq('1')
+
+      part_bc, body_bc = result.part('b[][c]')
+      expect(part_bc).to_not be_nil
+      expect(part_bc.filename).to eq('multipart_spec.rb')
+      expect(part_bc.headers['content-disposition'])
+        .to eq(
+          'form-data; name="b[][c]"; filename="multipart_spec.rb"'
+        )
+      expect(part_bc.headers['content-type']).to eq('text/x-ruby')
+      expect(part_bc.headers['content-transfer-encoding']).to eq('binary')
+      expect(body_bc).to eq(File.read(__FILE__))
+
+      part_bd, body_bd = result.part('b[][d]')
+      expect(part_bd).to_not be_nil
+      expect(part_bd.filename).to be_nil
+      expect(body_bd).to eq('2')
+    end
+  end
+
+  context 'UploadIO: when multipart objects in param' do
+    let(:payload) do
+      {
+        a: 1,
+        b: {
+          c: Faraday::FilePart.new(__FILE__, 'text/x-ruby', nil,
+                                   'Content-Disposition' => 'form-data; foo=1'),
+          d: 2
+        }
+      }
+    end
+    it_behaves_like 'a multipart request'
+
+    it 'forms a multipart request' do
+      response = conn.post('/echo', payload)
+
+      boundary = parse_multipart_boundary(response.headers['Content-Type'])
+      result = parse_multipart(boundary, response.body)
+      expect(result[:errors]).to be_empty
+
+      part_a, body_a = result.part('a')
+      expect(part_a).to_not be_nil
+      expect(part_a.filename).to be_nil
+      expect(body_a).to eq('1')
+
+      part_bc, body_bc = result.part('b[c]')
+      expect(part_bc).to_not be_nil
+      expect(part_bc.filename).to eq('multipart_spec.rb')
+      expect(part_bc.headers['content-disposition'])
+        .to eq(
+          'form-data; foo=1; name="b[c]"; filename="multipart_spec.rb"'
+        )
+      expect(part_bc.headers['content-type']).to eq('text/x-ruby')
+      expect(part_bc.headers['content-transfer-encoding']).to eq('binary')
+      expect(body_bc).to eq(File.read(__FILE__))
+
+      part_bd, body_bd = result.part('b[d]')
+      expect(part_bd).to_not be_nil
+      expect(part_bd.filename).to be_nil
+      expect(body_bd).to eq('2')
+    end
+  end
+
+  context 'UploadIO: when providing json and IO content in the same payload' do
+    let(:io) { StringIO.new('io-content') }
+    let(:json) do
+      {
+        b: 1,
+        c: 2
+      }.to_json
+    end
+
+    let(:payload) do
+      {
+        json: Faraday::ParamPart.new(json, 'application/json'),
+        io: Faraday::FilePart.new(io, 'application/pdf')
+      }
+    end
+
+    it_behaves_like 'a multipart request'
+
+    it 'forms a multipart request' do
+      response = conn.post('/echo', payload)
+
+      boundary = parse_multipart_boundary(response.headers['Content-Type'])
+      result = parse_multipart(boundary, response.body)
+      expect(result[:errors]).to be_empty
+
+      part_json, body_json = result.part('json')
+      expect(part_json).to_not be_nil
+      expect(part_json.mime).to eq('application/json')
+      expect(part_json.filename).to be_nil
+      expect(body_json).to eq(json)
+
+      part_io, body_io = result.part('io')
+      expect(part_io).to_not be_nil
+      expect(part_io.mime).to eq('application/pdf')
+      expect(part_io.filename).to eq('local.path')
+      expect(body_io).to eq(io.string)
+    end
+  end
+
+  context 'UploadIO: when multipart objects in array param' do
+    let(:payload) do
+      {
+        a: 1,
+        b: [{
+          c: Faraday::FilePart.new(__FILE__, 'text/x-ruby'),
+          d: 2
+        }]
+      }
+    end
+
+    it_behaves_like 'a multipart request'
+
+    it 'forms a multipart request' do
+      response = conn.post('/echo', payload)
+
+      boundary = parse_multipart_boundary(response.headers['Content-Type'])
+      result = parse_multipart(boundary, response.body)
+      expect(result[:errors]).to be_empty
+
+      part_a, body_a = result.part('a')
+      expect(part_a).to_not be_nil
+      expect(part_a.filename).to be_nil
+      expect(body_a).to eq('1')
+
+      part_bc, body_bc = result.part('b[][c]')
+      expect(part_bc).to_not be_nil
+      expect(part_bc.filename).to eq('multipart_spec.rb')
+      expect(part_bc.headers['content-disposition'])
+        .to eq(
+          'form-data; name="b[][c]"; filename="multipart_spec.rb"'
+        )
+      expect(part_bc.headers['content-type']).to eq('text/x-ruby')
+      expect(part_bc.headers['content-transfer-encoding']).to eq('binary')
+      expect(body_bc).to eq(File.read(__FILE__))
+
+      part_bd, body_bd = result.part('b[][d]')
+      expect(part_bd).to_not be_nil
+      expect(part_bd.filename).to be_nil
+      expect(body_bd).to eq('2')
+    end
+  end
+
+  context 'when passing flat_encode=true option' do
+    let(:options) { { flat_encode: true } }
+    let(:io) { StringIO.new('io-content') }
+    let(:payload) do
+      {
+        a: 1,
+        b: [
+          Faraday::FilePart.new(io, 'application/pdf'),
+          Faraday::FilePart.new(io, 'application/pdf')
+        ]
+      }
+    end
+
+    it_behaves_like 'a multipart request'
+
+    it 'encode params using flat encoder' do
+      response = conn.post('/echo', payload)
+
+      expect(response.body).to include('name="b"')
+      expect(response.body).not_to include('name="b[]"')
+    end
+  end
+end