bandwidth-sdk 11.0.0.pre.beta.1.1 → 11.0.0.pre.beta.2.0

data/spec/api_client_spec.rb

@@ -0,0 +1,377 @@
+# Unit tests for Bandwidth::ApiClient
+describe Bandwidth::ApiClient do
+  let(:api_client_default) { Bandwidth::ApiClient.new }
+  let(:config) { Bandwidth::Configuration.new }
+  let(:faraday_connection) { Faraday::Connection.new }
+  let(:api_client) { Bandwidth::ApiClient.new(config) }
+  let(:named_media_headers) { { 'content-disposition' => 'filename=test', 'content-type' => 'text/plain' } }
+  let(:media_data) { '123456' }
+  let(:media_headers) { { 'content-type' => 'text/plain' } }
+  let(:json_headers) { { 'content-type' => 'application/json' } }
+  let(:multipart_headers) { { 'Content-Type' => 'multipart/form-data' } }
+  let(:form_encoded_headers) { { 'Content-Type' => 'application/x-www-form-urlencoded' } }
+  let(:error_data) { '{"error": true}' }
+
+  describe '#call_api' do
+    it 'calls api and returns a tempfile with name from content-disposition header' do
+      stub_request(:get, 'https://messaging.bandwidth.com/api/v2/path').
+      to_return(status: 200, headers: media_headers, body: media_data)
+
+      opts = {
+        operation: :"MediaApi.get_media",
+        header_params: {},
+        query_params: {},
+        form_params: {},
+        body: nil,
+        auth_names: ['Basic'],
+        return_type: 'File'
+      }
+      data, status_code, headers = api_client.call_api(:GET, 'path', opts)
+
+      expect(status_code).to eq(200)
+      expect(headers).to eq(media_headers)
+      expect(data).to be_a(Tempfile)
+    end
+
+    it 'calls api and returns a tempfile' do
+      stub_request(:get, 'https://messaging.bandwidth.com/api/v2/path').
+      to_return(status: 200, headers: named_media_headers, body: media_data)
+
+      opts = {
+        operation: :"MediaApi.get_media",
+        header_params: {},
+        query_params: {},
+        form_params: {},
+        body: nil,
+        auth_names: ['Basic'],
+        return_type: 'File'
+      }
+      data, status_code, headers = api_client.call_api(:GET, 'path', opts)
+
+      expect(status_code).to eq(200)
+      expect(headers).to eq(named_media_headers)
+      expect(data).to be_a(Tempfile)
+    end
+
+    it 'calls api and returns binary data' do
+      stub_request(:get, 'https://messaging.bandwidth.com/api/v2/path').
+      to_return(status: 200, headers: media_headers, body: media_data)
+
+      api_client.config.return_binary_data = true
+      api_client.config.debugging = true
+
+      opts = {
+        operation: :"MediaApi.get_media",
+        header_params: {},
+        query_params: {},
+        form_params: {},
+        body: nil,
+        auth_names: ['Basic'],
+        return_type: 'File'
+      }
+      data, status_code, headers = api_client.call_api(:GET, 'path', opts)
+
+      expect(status_code).to eq(200)
+      expect(headers).to eq(media_headers)
+      expect(data).to eq(media_data)
+    end
+
+    it 'calls api and returns a hash' do
+      stub_request(:get, 'https://messaging.bandwidth.com/api/v2/path').
+      to_return(status: 200, headers: json_headers, body: '{"id": 1}')
+
+      opts = {
+        operation: :"MessagesApi.list_messages",
+        header_params: {},
+        query_params: {},
+        form_params: {},
+        body: nil,
+        auth_names: ['Basic'],
+        return_type: 'Hash<String, Integer>'
+      }
+      data, status_code, headers = api_client.call_api(:GET, 'path', opts)
+
+      expect(status_code).to eq(200)
+      expect(headers).to eq(json_headers)
+      expect(data).to eq({ id: 1 })
+    end
+
+    it 'posts data and returns nothing' do
+      stub_request(:post, 'https://messaging.bandwidth.com/api/v2/path').
+      to_return(status: 204)
+
+      api_client.config.debugging = true
+
+      opts = {
+        operation: :"MediaApi.upload_media",
+        header_params: {},
+        query_params: {},
+        form_params: {},
+        body: { id: 1 },
+        auth_names: ['Basic'],
+        return_type: nil
+      }
+      data, status_code, headers = api_client.call_api(:POST, 'path', opts)
+
+      expect(status_code).to eq(204)
+      expect(data).to be nil
+    end
+
+    it 'posts multipart/form-data and returns nothing' do
+      stub_request(:post, 'https://messaging.bandwidth.com/api/v2/path').
+      to_return(status: 204)
+
+      opts = {
+        operation: :"MediaApi.upload_media",
+        header_params: multipart_headers,
+        query_params: {},
+        form_params: { file: Tempfile.new('filename'), array: [1, 2, 3], string: '123' },
+        body: nil,
+        auth_names: ['Basic'],
+        return_type: nil
+      }
+      data, status_code, headers = api_client.call_api(:POST, 'path', opts)
+
+      expect(status_code).to eq(204)
+      expect(data).to be nil
+    end
+
+    it 'calls api and handles HTTP error' do
+      stub_request(:post, 'https://messaging.bandwidth.com/api/v2/path').
+      to_return(status: 400, headers: json_headers, body: error_data)
+
+      opts = {
+        operation: :"MediaApi.upload_media",
+        header_params: {},
+        query_params: {},
+        form_params: {},
+        body: { id: 1 },
+        auth_names: ['Basic'],
+        return_type: nil
+      }
+      
+      expect {
+        api_client.call_api(:POST, 'path', opts)
+      }.to raise_error { |e|
+        expect(e).to be_instance_of(Bandwidth::ApiError)
+        expect(e.code).to eq(400)
+        expect(e.response_headers).to eq(json_headers)
+        expect(e.response_body).to eq('{"error": true}')
+      }
+    end
+
+    it 'calls api and handles timeout error' do
+      stub_request(:post, 'https://messaging.bandwidth.com/api/v2/path').
+      to_raise(Faraday::TimeoutError)
+
+      opts = {
+        operation: :"MediaApi.upload_media",
+        header_params: {},
+        query_params: {},
+        form_params: {},
+        body: { id: 1 },
+        auth_names: ['Basic'],
+        return_type: nil
+      }
+      
+      expect {
+        api_client.call_api(:POST, 'path', opts)
+      }.to raise_error { |e|
+        expect(e).to be_instance_of(Bandwidth::ApiError)
+        expect(e.message).to eq('Connection timed out')
+      }
+    end
+
+    it 'calls api and handles connection error' do
+      stub_request(:post, 'https://messaging.bandwidth.com/api/v2/path').
+      to_raise(Faraday::ConnectionFailed)
+
+      opts = {
+        operation: :"MediaApi.upload_media",
+        header_params: {},
+        query_params: {},
+        form_params: {},
+        body: { id: 1 },
+        auth_names: ['Basic'],
+        return_type: nil
+      }
+      
+      expect {
+        api_client.call_api(:POST, 'path', opts)
+      }.to raise_error { |e|
+        expect(e).to be_instance_of(Bandwidth::ApiError)
+        expect(e.message).to eq('Connection failed')
+      }
+    end
+  end
+
+  describe '#build_request_body' do
+    it 'builds application/x-www-form-urlencoded' do
+      expect(api_client_default.build_request_body(form_encoded_headers, { id: 1 }, nil)).to eq('id=1')
+    end
+
+    it 'builds empty body' do
+      expect(api_client_default.build_request_body({}, {}, nil)).to be nil
+    end
+  end
+
+  describe '#deserialize' do
+    it 'throws on invalid JSON when expecting JSON' do
+      headers = { 'Content-Type' => 'application/json' }
+      response = double('response', headers: headers, body: '{id 1}')
+      expect {
+        api_client_default.deserialize(response, 'Hash<String, Integer>')
+      }.to raise_error(JSON::ParserError, 'unexpected token at \'{id 1}]\'')
+    end
+
+    it 'rescues invalid JSON when expecting non-JSON' do
+      headers = { 'Content-Type' => 'application/json' }
+      response = double('response', headers: headers, body: '2022-06-16')
+      data = api_client_default.deserialize(response, 'Date')
+      expect(data).to eq(Date.parse('2022-06-16'))
+    end
+  end
+
+  describe '#basic_auth' do
+    it 'sets basic auth for the connection' do
+      api_client.config.username = 'username'
+      api_client.config.password = 'password'
+      api_client.basic_auth(faraday_connection)
+      expect(api_client.config.username).to eq('username')
+      expect(api_client.config.password).to eq('password')
+    end
+  end
+
+  describe '#json_mime?' do
+    it 'checks if the given MIME is a JSON MIME' do
+      expect(api_client_default.json_mime?(nil)).to eq false
+      expect(api_client_default.json_mime?('')).to eq false
+
+      expect(api_client_default.json_mime?('application/json')).to eq true
+      expect(api_client_default.json_mime?('application/json; charset=UTF8')).to eq true
+      expect(api_client_default.json_mime?('APPLICATION/JSON')).to eq true
+
+      expect(api_client_default.json_mime?('application/xml')).to eq false
+      expect(api_client_default.json_mime?('text/plain')).to eq false
+      expect(api_client_default.json_mime?('application/jsonp')).to eq false
+    end
+  end
+
+  describe '#convert_to_type' do
+    it 'conversts data to the given return type' do
+      expect(api_client_default.convert_to_type(1, 'String')).to eq('1')
+      expect(api_client_default.convert_to_type('1', 'Integer')).to eq(1)
+      expect(api_client_default.convert_to_type('1', 'Float')).to eq(1.0)
+      expect(api_client_default.convert_to_type(1, 'Boolean')).to be false
+      expect(api_client_default.convert_to_type('2022-06-16T13:15:07.160Z', 'Time')).to eq(Time.parse('2022-06-16T13:15:07.160Z'))
+      expect(api_client_default.convert_to_type('2022-06-16', 'Date')).to eq(Date.parse('2022-06-16'))
+      expect(api_client_default.convert_to_type({ id: 1 }, 'Object')).to eq({ id: 1 })
+      expect(api_client_default.convert_to_type([[12, 34], [56]], 'Array<Array<Integer>>')).to eq([[12, 34], [56]])
+      expect(api_client_default.convert_to_type({ "id": 'test' }, 'Hash<String, String>')).to eq({ id: 'test' })
+      expect(api_client_default.convert_to_type({ set_or_expired: true }, 'DeferredResult')).to be_instance_of(Bandwidth::DeferredResult)
+    end
+  end
+
+  describe '#sanitize_filename' do
+    it 'sanitizes a filename by removing the path' do
+      expect(api_client_default.sanitize_filename('sun')).to eq('sun')
+      expect(api_client_default.sanitize_filename('sun.gif')).to eq('sun.gif')
+      expect(api_client_default.sanitize_filename('../sun.gif')).to eq('sun.gif')
+      expect(api_client_default.sanitize_filename('/var/tmp/sun.gif')).to eq('sun.gif')
+      expect(api_client_default.sanitize_filename('./sun.gif')).to eq('sun.gif')
+      expect(api_client_default.sanitize_filename('..\sun.gif')).to eq('sun.gif')
+      expect(api_client_default.sanitize_filename('\var\tmp\sun.gif')).to eq('sun.gif')
+      expect(api_client_default.sanitize_filename('c:\var\tmp\sun.gif')).to eq('sun.gif')
+      expect(api_client_default.sanitize_filename('.\sun.gif')).to eq('sun.gif')
+    end
+  end
+  
+  describe '#build_request_url' do
+    it 'adds leading and trailing slashes to path' do
+      expect(api_client_default.build_request_url('test/path')).to eq('/test/path')
+    end
+  end
+  
+  describe '#update_params_for_auth' do
+    it 'updates header and query params based on authentication settings' do
+      
+    end
+  end
+  
+  describe '#user_agent=' do
+    it 'sets user agent in HTTP header' do
+      api_client_default.user_agent = 'test-user-agent'
+      expect(api_client_default.default_headers['User-Agent']).to eq('test-user-agent')
+    end
+  end
+
+  describe '#select_header_accept' do
+    it 'returns Accept header based on an array of accepts provided' do
+      expect(api_client_default.select_header_accept(nil)).to be_nil
+      expect(api_client_default.select_header_accept([])).to be_nil
+
+      expect(api_client_default.select_header_accept(['application/json'])).to eq('application/json')
+      expect(api_client_default.select_header_accept(['application/xml', 'application/json; charset=UTF8'])).to eq('application/json; charset=UTF8')
+      expect(api_client_default.select_header_accept(['APPLICATION/JSON', 'text/html'])).to eq('APPLICATION/JSON')
+
+      expect(api_client_default.select_header_accept(['application/xml'])).to eq('application/xml')
+      expect(api_client_default.select_header_accept(['text/html', 'application/xml'])).to eq('text/html,application/xml')
+    end
+  end
+
+  describe '#select_header_content_type' do
+    it 'returns Content-Type header based on an array of content types provided' do
+      expect(api_client_default.select_header_content_type(nil)).to be_nil
+      expect(api_client_default.select_header_content_type([])).to be_nil
+
+      expect(api_client_default.select_header_content_type(['application/json'])).to eq('application/json')
+      expect(api_client_default.select_header_content_type(['application/xml', 'application/json; charset=UTF8'])).to eq('application/json; charset=UTF8')
+      expect(api_client_default.select_header_content_type(['APPLICATION/JSON', 'text/html'])).to eq('APPLICATION/JSON')
+      expect(api_client_default.select_header_content_type(['application/xml'])).to eq('application/xml')
+      expect(api_client_default.select_header_content_type(['text/plain', 'application/xml'])).to eq('text/plain')
+    end
+  end
+  
+  describe '#object_to_http_body' do
+    it 'converts array to JSON string' do
+      model = [1, 2, 3]
+      expect(api_client_default.object_to_http_body(model)).to eq('[1,2,3]')
+    end
+
+    it 'converts hash to JSON string' do
+      model = { id: 1 }
+      expect(api_client_default.object_to_http_body(model)).to eq('{"id":1}')
+    end
+  end
+  
+  describe '#object_to_hash' do
+    it 'returns object when object cannot be converted to hash' do
+      model = Object.new
+      model.instance_variable_set(:@id, 1)
+      expect(api_client_default.object_to_hash(model)).to be_instance_of(Object)
+      expect(api_client_default.object_to_hash(model).instance_variable_get('@id')).to eq(1)
+    end
+
+    it 'returns hash when object can be converted to hash' do
+      model = Bandwidth::DeferredResult.new({
+        set_or_expired: true
+      })
+      expected = { setOrExpired: true }
+      expect(api_client_default.object_to_hash(model)).to eq(expected)
+    end
+  end
+
+  describe '#build_collection_param' do
+    it 'builds parameter value according to the given collection format' do
+      param = ['aa', 'bb', 'cc']
+      expect(api_client_default.build_collection_param(param, :csv)).to eq('aa,bb,cc')
+      expect(api_client_default.build_collection_param(param, :ssv)).to eq('aa bb cc')
+      expect(api_client_default.build_collection_param(param, :tsv)).to eq("aa\tbb\tcc")
+      expect(api_client_default.build_collection_param(param, :pipes)).to eq('aa|bb|cc')
+      expect(api_client_default.build_collection_param(param, :multi)).to eq(['aa', 'bb', 'cc'])
+      expect { 
+        api_client_default.build_collection_param(param, :INVALID) 
+      }.to raise_error(RuntimeError, 'unknown collection format: :INVALID')
+    end
+  end
+end

data/spec/api_error_spec.rb

@@ -0,0 +1,23 @@
+# Unit tests for Bandwidth::ApiError
+describe Bandwidth::ApiError do
+  describe '#initialize' do
+    it 'initializes an instance of ApiError with message' do
+      api_error = Bandwidth::ApiError.new({ message: 'test' })
+      expect(api_error.message).to eq('test')
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns message when to_s is called' do
+      api_error = Bandwidth::ApiError.new('test')
+      expect(api_error.to_s).to eq('test')
+    end
+  end
+
+  describe '#message' do
+    it 'returns default error message when none supplied' do
+      api_error = Bandwidth::ApiError.new
+      expect(api_error.message).to eq('Error message: the server returns an error')
+    end
+  end
+end

data/spec/call_utils.rb

@@ -2,40 +2,40 @@
 # These are reused in multiple tests
 
 def setup_manteca(type)
-    manteca_body = {
-      os: OPERATING_SYSTEM,
-      language: RUBY_VERSION,
-      type: type
-    }
-    manteca_test_url = URI(MANTECA_BASE_URL + "/tests")
-    manteca_header = { 'Content-Type': 'application/json' }
+  manteca_body = {
+    os: OPERATING_SYSTEM,
+    language: RUBY_VERSION,
+    type: type
+  }
+  manteca_test_url = URI(MANTECA_BASE_URL + '/tests')
+  manteca_header = { 'Content-Type': 'application/json' }
   
-    begin
-      test_id = Net::HTTP.post(manteca_test_url, manteca_body.to_json, manteca_header)
-      return test_id.body.to_s
-    rescue => e
-      puts e.inspect
-    end
+  begin
+    test_id = Net::HTTP.post(manteca_test_url, manteca_body.to_json, manteca_header)
+    test_id.body.to_s
+  rescue => e
+    puts e.inspect
+  end
 end
 
-def create_manteca_call(tag = "ruby", answer_path = "/bxml/pause", calls_api)
-    manteca_call_body = Bandwidth::CreateCall.new(
-      application_id: MANTECA_APPLICATION_ID,
-      to: MANTECA_IDLE_NUMBER,
-      from: MANTECA_ACTIVE_NUMBER,
-      answer_url: MANTECA_BASE_URL + answer_path,
-      tag: tag
-    )
+def create_manteca_call(tag = 'ruby', answer_path = '/bxml/pause', calls_api)
+  manteca_call_body = Bandwidth::CreateCall.new(
+    application_id: MANTECA_APPLICATION_ID,
+    to: MANTECA_IDLE_NUMBER,
+    from: MANTECA_ACTIVE_NUMBER,
+    answer_url: MANTECA_BASE_URL + answer_path,
+    tag: tag
+  )
   
-    response = calls_api.create_call(BW_ACCOUNT_ID, manteca_call_body)
-    $active_calls.append(response.call_id)
-    return response.call_id
+  response = calls_api.create_call(BW_ACCOUNT_ID, manteca_call_body)
+  $active_calls.append(response.call_id)
+  response.call_id
 end
 
 def get_manteca_test_status(test_id)
-  manteca_status_url = URI(MANTECA_BASE_URL + "/tests/" + test_id)
+  manteca_status_url = URI(MANTECA_BASE_URL + '/tests/' + test_id)
   response = JSON.parse(Net::HTTP.get(manteca_status_url))
-  return response
+  response
 end
 
 def cleanup_calls(calls, calls_api)
@@ -48,7 +48,7 @@ def cleanup_calls(calls, calls_api)
   end
 
   if (calls.length > 0)
-    error_message = "Failed to terminate all calls" + calls.to_s
+    error_message = 'Failed to terminate all calls' + calls.to_s
     raise StandardError.new error_message
   end
 end
@@ -70,5 +70,5 @@ def call_ended(call_id, calls_api)
     return true
   end
 
-  return false
+  false
 end

data/spec/configuration_spec.rb

@@ -0,0 +1,178 @@
+require 'uri'
+
+# Unit tests for Bandwidth::Configuration
+describe Bandwidth::Configuration do
+  let(:config) { Bandwidth::Configuration.new }
+  let(:faraday_connection) { Faraday::Connection.new }
+  let(:uri) { URI.parse(BASE_CALLBACK_URL + '/path') }
+  let(:token) { 'abcd1234' }
+  let(:server) { [
+    {
+      url: 'https://voice.bandwidth.com/api/{enum_var}/{default_var}',
+      description: 'Production',
+      variables: {
+        enum_var: {
+          enum_values: ['v1', 'v2', 'v3'],
+          default_value: 'v2'
+        },
+        default_var: {
+          default_value: 'default_value'
+        }
+      }
+    }
+  ] }
+
+  describe '#configure' do
+    it 'configures a Configuration instance using a a block' do
+      config.configure do |c|
+        c.scheme = uri.scheme
+        c.host = uri.host
+        c.base_path = uri.path
+      end
+      expect(config.scheme).to eq(uri.scheme)
+      expect(config.host).to eq(uri.host)
+      expect(config.base_path).to eq(uri.path)
+    end
+  end
+
+  describe 'custom attribute writers' do
+    it '#scheme=' do
+      config.scheme = 'scheme://'
+      expect(config.scheme).to eq('scheme')
+    end
+
+    it '#host=' do
+      config.host = 'https://hostname'
+      expect(config.host).to eq('hostname')
+    end
+
+    it '#base_path=' do
+      config.base_path = 'basepath'
+      expect(config.base_path).to eq('/basepath')
+    end
+  end
+
+  describe '#base_url' do
+    it 'Returns default base URL when server_index is nil' do
+      config.server_index = nil
+      expect(config.base_url).to eq('http://localhost')
+    end
+
+    it 'returns empty string when invalid operation is passed' do
+      expect(config.base_url('invalid_operation')).to eq('')
+    end
+
+    it 'returns proper base URL when server index is set' do
+      operation, server = config.operation_server_settings.first
+      expect(config.base_url(operation)).to eq(server[0][:url])
+    end
+  end
+
+  describe '#api_key_with_prefix' do
+    it 'gets API key without prefix' do
+      config.api_key['Authorization'] = token
+      expect(config.api_key_with_prefix('Authorization')).to eq(token)
+    end
+
+    it 'gets API key wit prefix' do
+      config.api_key_prefix['Authorization'] = 'Token'
+      config.api_key['Authorization'] = token
+      expect(config.api_key_with_prefix('Authorization')).to eq("Token #{token}")
+    end
+  end
+
+  describe '#access_token_with_refresh' do
+    it 'gets the static access_token when no access_token_getter is defined' do
+      config.access_token = token
+      expect(config.access_token_with_refresh).to eq(token)
+    end
+
+    it 'gets access_token using access_token_getter' do
+      config.access_token_getter = proc { token }
+      expect(config.access_token_with_refresh).to eq(token)
+    end
+  end
+
+  describe '#basic_auth_token' do
+    it 'gets Basic Auth token string' do
+      config.username = 'username'
+      config.password = 'password'
+      expect(config.basic_auth_token).to eq('Basic dXNlcm5hbWU6cGFzc3dvcmQ=')
+    end
+  end
+
+  describe '#auth_settings' do
+    it 'returns Auth Settings hash for api client' do
+      basic_auth = config.auth_settings['Basic']
+      expect(basic_auth[:type]).to eq('basic')
+      expect(basic_auth[:in]).to eq('header')
+      expect(basic_auth[:key]).to eq('Authorization')
+      expect(basic_auth[:value]).to eq('Basic Og==')
+    end
+  end
+
+  describe '#server_url' do
+    it 'returns URL with enum variable substitued' do
+      expect(config.server_url(0, { enum_var: 'v3' }, server)).to eq('https://voice.bandwidth.com/api/v3/default_value')
+    end
+
+    it 'causes an ArgumentError by passing an invalid index' do
+      expect {
+        config.server_url(100)
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'causes an ArgumentError by passing an invalid value to an enum variable' do
+      expect {
+        config.server_url(0, { enum_var: 'v4' }, server)
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe 'configure faraday connection' do
+    it '#configure_faraday_connection #configure_connection' do
+      config.configure_faraday_connection do |c|
+        config.username = 'username'
+      end
+      config.configure_connection(faraday_connection)
+      expect(config.username).to eq('username')
+    end
+  end
+
+  describe '#set_faraday_middleware' do
+    it '#use' do
+      config.use(Faraday::Request::UrlEncoded)
+      expect(config.instance_variable_get('@middlewares')[:use]).to eq([[Faraday::Request::UrlEncoded, [], nil]])
+    end
+
+    it '#request' do
+      config.request(:retry, max: 3, methods: [:get, :post], retry_statuses: [503])
+      expect(config.instance_variable_get('@middlewares')[:request]).to eq([[:retry, [{ :max => 3, :methods => [:get, :post], :retry_statuses => [503] }], nil]])
+    end
+
+    it '#response' do
+      config.response(:logger, nil, { bodies: true, log_level: :debug })
+      expect(config.instance_variable_get('@middlewares')[:response]).to eq([[:logger, [nil, { :bodies => true, :log_level => :debug }], nil]])
+    end
+
+    it 'causes an ArgumentError by passing an invalid middleware operation' do
+      expect {
+        config.set_faraday_middleware(:invalid_operation, Faraday::Request::UrlEncoded)
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#configure_middleware' do
+    it 'builds connection using supplied response middleware' do
+      config.response(:logger)
+      config.configure_middleware(faraday_connection)
+      expect(faraday_connection.builder.handlers).to include(Faraday::Response::Logger)
+    end
+
+    it 'builds connection using deleted middleware' do
+      config.set_faraday_middleware(:delete, Faraday::Request::UrlEncoded)
+      config.configure_middleware(faraday_connection)
+      expect(faraday_connection.builder.handlers).to eq([])
+    end
+  end
+end