acquiring-sdk-ruby 0.1.0

data/spec/integration/multipart_form_data_spec.rb

@@ -0,0 +1,216 @@
+require 'json'
+require 'spec_helper'
+require 'integration_setup'
+require 'webmock/rspec'
+require 'worldline/acquiring/sdk/factory'
+require 'worldline/acquiring/sdk/communication/multipart_form_data_object'
+require 'worldline/acquiring/sdk/communication/multipart_form_data_request'
+require 'worldline/acquiring/sdk/domain/data_object'
+require 'worldline/acquiring/sdk/domain/uploadable_file'
+
+describe 'multipart/form-data support' do
+  HTTPBIN_URL = ENV['httpbin_url'] || 'http://httpbin.org'
+
+  before(:context) { WebMock.allow_net_connect! }
+  after(:context) { WebMock.disable_net_connect! }
+
+  it 'Can send a Multipart Form Data Object POST upload with a response' do
+    configuration = Integration.init_communicator_configuration
+    configuration.api_endpoint = HTTPBIN_URL
+
+    multipart = Worldline::Acquiring::SDK::Communication::MultipartFormDataObject.new
+    multipart.add_file 'file', Worldline::Acquiring::SDK::Domain::UploadableFile.new(
+      'file.txt', 'file-content', 'text/plain'
+    )
+
+    multipart.add_value 'value', 'Hello World'
+
+    communicator = Worldline::Acquiring::SDK::Factory.create_communicator_from_configuration configuration
+
+    response = communicator.post('/anything/operations', nil, nil, multipart,
+                                 HttpBinResponse, nil)
+
+    expect(response.form['value']).to eq 'Hello World'
+    expect(response.files['file']).to eq 'file-content'
+  end
+
+  it 'Can send a Multipart Form Data Request POST upload with a response' do
+    configuration = Integration.init_communicator_configuration
+    configuration.api_endpoint = HTTPBIN_URL
+
+    multipart = Worldline::Acquiring::SDK::Communication::MultipartFormDataObject.new
+    multipart.add_file 'file', Worldline::Acquiring::SDK::Domain::UploadableFile.new(
+      'file.txt', 'file-content', 'text-plain'
+    )
+
+    multipart.add_value 'value', 'Hello World'
+
+    communicator = Worldline::Acquiring::SDK::Factory.create_communicator_from_configuration configuration
+
+    response = communicator.post '/anything/operations', nil, nil,
+                                 MultipartFormDataObjectWrapper.new(multipart), HttpBinResponse, nil
+
+    expect(response.form['value']).to eq 'Hello World'
+    expect(response.files['file']).to eq 'file-content'
+  end
+
+  it 'Can send a Multipart Form Data Object POST upload with a binary response' do
+    configuration = Integration.init_communicator_configuration
+    configuration.api_endpoint = HTTPBIN_URL
+
+    multipart = Worldline::Acquiring::SDK::Communication::MultipartFormDataObject.new
+    multipart.add_file 'file', Worldline::Acquiring::SDK::Domain::UploadableFile.new(
+      'file.txt', 'file-content', 'text/plain'
+    )
+    multipart.add_value 'value', 'Hello World'
+
+    communicator = Worldline::Acquiring::SDK::Factory.create_communicator_from_configuration configuration
+
+    data = ''
+    communicator.post_with_binary_response '/anything/operations', nil, nil,
+                                           multipart, nil do |_, c|
+      data = c.read.force_encoding('UTF-8')
+    end
+    response = JSON.parse data
+
+    expect(response['form']['value']).to eq 'Hello World'
+    expect(response['files']['file']).to eq 'file-content'
+  end
+
+  it 'Can send a Multipart Form Data Request POST upload with a binary response' do
+    configuration = Integration.init_communicator_configuration
+    configuration.api_endpoint = HTTPBIN_URL
+
+    multipart = Worldline::Acquiring::SDK::Communication::MultipartFormDataObject.new
+    multipart.add_file 'file', Worldline::Acquiring::SDK::Domain::UploadableFile.new(
+      'file.txt', 'file-content', 'text/plain'
+    )
+    multipart.add_value 'value', 'Hello World'
+
+    communicator = Worldline::Acquiring::SDK::Factory.create_communicator_from_configuration configuration
+
+    data = ''
+    communicator.post_with_binary_response '/anything/operations', nil, nil,
+                                           MultipartFormDataObjectWrapper.new(multipart), nil do |_, c|
+      data = c.read.force_encoding('UTF-8')
+    end
+    response = JSON.parse data
+
+    expect(response['form']['value']).to eq 'Hello World'
+    expect(response['files']['file']).to eq 'file-content'
+  end
+
+  it 'Can send a Multipart Form Data Object PUT upload with a response' do
+    configuration = Integration.init_communicator_configuration
+    configuration.api_endpoint = HTTPBIN_URL
+
+    multipart = Worldline::Acquiring::SDK::Communication::MultipartFormDataObject.new
+    multipart.add_file 'file', Worldline::Acquiring::SDK::Domain::UploadableFile.new(
+      'file.txt', 'file-content', 'text/plain'
+    )
+
+    multipart.add_value 'value', 'Hello World'
+
+    communicator = Worldline::Acquiring::SDK::Factory.create_communicator_from_configuration configuration
+
+    response = communicator.put('/anything/operations', nil, nil, multipart,
+                                HttpBinResponse, nil)
+
+    expect(response.form['value']).to eq 'Hello World'
+    expect(response.files['file']).to eq 'file-content'
+  end
+
+  it 'Can send a Multipart Form Data Request PUT upload with a response' do
+    configuration = Integration.init_communicator_configuration
+    configuration.api_endpoint = HTTPBIN_URL
+
+    multipart = Worldline::Acquiring::SDK::Communication::MultipartFormDataObject.new
+    multipart.add_file 'file', Worldline::Acquiring::SDK::Domain::UploadableFile.new(
+      'file.txt', 'file-content', 'text-plain'
+    )
+
+    multipart.add_value 'value', 'Hello World'
+
+    communicator = Worldline::Acquiring::SDK::Factory.create_communicator_from_configuration configuration
+
+    response = communicator.put '/anything/operations', nil, nil,
+                                MultipartFormDataObjectWrapper.new(multipart), HttpBinResponse, nil
+
+    expect(response.form['value']).to eq 'Hello World'
+    expect(response.files['file']).to eq 'file-content'
+  end
+
+  it 'Can send a Multipart Form Data Object PUT upload with a binary response' do
+    configuration = Integration.init_communicator_configuration
+    configuration.api_endpoint = HTTPBIN_URL
+
+    multipart = Worldline::Acquiring::SDK::Communication::MultipartFormDataObject.new
+    multipart.add_file 'file', Worldline::Acquiring::SDK::Domain::UploadableFile.new(
+      'file.txt', 'file-content', 'text/plain'
+    )
+    multipart.add_value 'value', 'Hello World'
+
+    communicator = Worldline::Acquiring::SDK::Factory.create_communicator_from_configuration configuration
+
+    data = ''
+    communicator.put_with_binary_response '/anything/operations', nil, nil,
+                                          multipart, nil do |_, c|
+      data = c.read.force_encoding('UTF-8')
+    end
+    response = JSON.parse data
+
+    expect(response['form']['value']).to eq 'Hello World'
+    expect(response['files']['file']).to eq 'file-content'
+  end
+
+  it 'Can send a Multipart Form Data Request PUT upload with a binary response' do
+    configuration = Integration.init_communicator_configuration
+    configuration.api_endpoint = HTTPBIN_URL
+
+    multipart = Worldline::Acquiring::SDK::Communication::MultipartFormDataObject.new
+    multipart.add_file 'file', Worldline::Acquiring::SDK::Domain::UploadableFile.new(
+      'file.txt', 'file-content', 'text/plain'
+    )
+    multipart.add_value 'value', 'Hello World'
+
+    communicator = Worldline::Acquiring::SDK::Factory.create_communicator_from_configuration configuration
+
+    data = ''
+    communicator.put_with_binary_response '/anything/operations', nil, nil,
+                                                     MultipartFormDataObjectWrapper.new(multipart), nil do |_, c|
+      data = c.read.force_encoding('UTF-8')
+    end
+    response = JSON.parse data
+
+    expect(response['form']['value']).to eq 'Hello World'
+    expect(response['files']['file']).to eq 'file-content'
+  end
+end
+
+class HttpBinResponse < Worldline::Acquiring::SDK::Domain::DataObject
+  @form = nil
+  @files = nil
+
+  attr_reader :form
+  attr_reader :files
+
+  def from_hash(hash)
+    super
+    @form = hash['form'] if hash.key? 'form'
+    @files = hash['files'] if hash.key? 'files'
+  end
+end
+
+class MultipartFormDataObjectWrapper < Worldline::Acquiring::SDK::Communication::MultipartFormDataRequest
+  @multipart = nil
+
+  attr_reader :multipart
+
+  def initialize(multipart)
+    @multipart = multipart
+  end
+
+  def to_multipart_form_data_object
+    @multipart
+  end
+end

data/spec/integration/process_payment_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'yaml'
+require 'integration_setup'
+require 'webmock/rspec'
+require 'worldline/acquiring/sdk/v1/acquirer/merchant/payments/get_payment_status_params'
+
+describe 'process payment' do
+
+  before(:context){WebMock.allow_net_connect!}
+  after(:context){WebMock.disable_net_connect!}
+
+  it 'can be accessed' do
+    Integration.init_client(false) do |client|
+      payments_client = client.v1.acquirer(Integration::ACQUIRER_ID).merchant(Integration::MERCHANT_ID).payments
+
+      request = Integration.get_api_payment_request
+      response = payments_client.process_payment(request)
+
+      expect(response.operation_id).to eq(request.operation_id)
+      expect(response.response_code).to eq('0')
+      expect(response.response_code_category).to eq('APPROVED')
+      expect(response.response_code_description).to_not be_nil
+      expect(response.status).to eq('AUTHORIZED')
+      expect(response.initial_authorization_code).to_not be_nil
+      expect(response.payment_id).to_not be_nil
+      expect(response.total_authorized_amount).to_not be_nil
+      expect(response.total_authorized_amount.amount).to eq(200)
+      expect(response.total_authorized_amount.currency_code).to eq('GBP')
+      expect(response.total_authorized_amount.number_of_decimals).to eq(2)
+
+      payment_id = response.payment_id
+
+      query = Worldline::Acquiring::SDK::V1::Acquirer::Merchant::Payments::GetPaymentStatusParams.new
+      query.return_operations = true
+
+      status = payments_client.get_payment_status(payment_id, query)
+
+      expect(status.initial_authorization_code).to_not be_nil
+      expect(status.payment_id).to eq(payment_id)
+      expect(status.status).to eq('AUTHORIZED')
+    end
+  end
+end

data/spec/integration/request_dcc_rate_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'yaml'
+require 'integration_setup'
+require 'webmock/rspec'
+
+describe 'request DCC rate' do
+
+  before(:context){WebMock.allow_net_connect!}
+  after(:context){WebMock.disable_net_connect!}
+
+  it 'can be accessed' do
+    Integration.init_client(false) do |client|
+      request = Integration.get_dcc_rate_request
+      response = client.v1.acquirer(Integration::ACQUIRER_ID).merchant(Integration::MERCHANT_ID).dynamic_currency_conversion.request_dcc_rate(request)
+
+      expect(response.proposal).to_not be_nil
+      expect(response.proposal.original_amount).to_not be_nil
+      expect(response.proposal.original_amount.amount).to eq(request.transaction.amount.amount)
+      expect(response.proposal.original_amount.currency_code).to eq(request.transaction.amount.currency_code)
+      expect(response.proposal.original_amount.number_of_decimals).to eq(request.transaction.amount.number_of_decimals)
+      expect(response.proposal.resulting_amount.currency_code).to eq(request.target_currency)
+    end
+  end
+end

data/spec/integration/sdk_proxy_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require 'integration_setup'
+require 'worldline/acquiring/sdk/factory'
+require 'worldline/acquiring/sdk/communicator_configuration'
+require 'worldline/acquiring/sdk/proxy_configuration'
+require 'worldline/acquiring/sdk/communication/communication_exception'
+
+require 'webrick'
+require 'webrick/httpproxy'
+
+describe 'proxies' do
+
+  context 'using proxy server' do
+    proxy_server = nil
+
+    password_filename = 'password_file'
+
+    before :context do
+      WebMock.allow_net_connect!
+
+      # set up a proxy
+      proxy_server = Thread.new do
+        config = { Realm: 'testing' }
+        htpasswd = WEBrick::HTTPAuth::Htpasswd.new(password_filename) # create new Apache password file
+        proxy_configuration = Integration.init_communicator_configuration(properties_url: Integration::PROPERTIES_URI_PROXY).proxy_configuration
+        htpasswd.set_passwd config[:Realm], proxy_configuration.username, proxy_configuration.password
+        config[:UserDB] = htpasswd
+        basic_auth = WEBrick::HTTPAuth::ProxyBasicAuth.new(config)
+
+        auth_handler = Proc.new do |req, res|
+          basic_auth.authenticate(req, res)
+        end
+
+        proxy = WEBrick::HTTPProxyServer.new(Port: 9999, ProxyVia: false,
+                                             ProxyAuthProc: auth_handler)
+        Signal.trap('INT') do
+            proxy.shutdown
+        end
+
+        proxy.start
+      end
+
+      sleep 1 # wait for the proxy server
+    end
+
+    after :context do
+      Thread.kill(proxy_server)
+      File.delete(password_filename)
+      WebMock.disable_net_connect!
+    end
+
+    # NOTE: if this test is running for a long time with no response
+    # check https://api.preprod.acquiring.worldline-solutions.com because this is where merchant
+    # connects to.
+    it 'can be connected to' do
+      request = Integration.get_dcc_rate_request
+
+      Integration.init_client(true) do |client|
+        response = client.v1.acquirer(Integration::ACQUIRER_ID).merchant(Integration::MERCHANT_ID).dynamic_currency_conversion.request_dcc_rate(request)
+
+        expect(response.proposal).to_not be_nil
+        expect(response.proposal.original_amount).to_not be_nil
+        expect(response.proposal.original_amount.amount).to eq(request.transaction.amount.amount)
+        expect(response.proposal.original_amount.currency_code).to eq(request.transaction.amount.currency_code)
+        expect(response.proposal.original_amount.number_of_decimals).to eq(request.transaction.amount.number_of_decimals)
+        expect(response.proposal.resulting_amount.currency_code).to eq(request.target_currency)
+      end
+    end
+  end # end of using proxy server
+end

data/spec/integration_setup.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+require 'date'
+require 'securerandom'
+require 'yaml'
+require 'worldline/acquiring/sdk/v1/acquirer'
+require 'worldline/acquiring/sdk/v1/domain'
+
+module Integration
+  ACQUIRER_ID = ENV['acquiring_api_acquirerId']
+  MERCHANT_ID = ENV['acquiring_api_merchantId']
+  OAUTH2_CLIENT_ID = ENV['acquiring_api_oauth2_clientId']
+  OAUTH2_CLIENT_SECRET = ENV['acquiring_api_oauth2_clientSecret']
+  OAUTH2_TOKEN_URI = ENV['acquiring_api_oauth2_tokenUri']
+  raise 'could not access environment variable acquiring_api_acquirerId required for testing' unless ACQUIRER_ID
+  raise 'could not access environment variable acquiring_api_merchantId required for testing' unless MERCHANT_ID
+  raise 'could not access environment variable acquiring_api_oauth2_clientId required for testing' unless OAUTH2_CLIENT_ID
+  raise 'could not access environment variable acquiring_api_oauth2_clientSecret required for testing' unless OAUTH2_CLIENT_SECRET
+  raise 'could not access environment variable acquiring_api_oauth2_tokenUri required for testing' unless OAUTH2_TOKEN_URI
+  PROPERTIES_URI_OAUTH2 = File.absolute_path(File.join(__FILE__, '../fixtures/resources/properties.oauth2.yml'))
+  PROPERTIES_URI_PROXY = File.absolute_path(File.join(__FILE__, '../fixtures/resources/properties.proxy.yml'))
+
+  def self.create_uri(scheme, host, port)
+    if port == -1
+      "#{scheme}://#{host}"
+    else
+      "#{scheme}://#{host}:#{port.to_s}"
+    end
+  end
+
+  def self.init_communicator_configuration(properties_url: PROPERTIES_URI_OAUTH2, max_connections: nil)
+    yaml = YAML.load_file(properties_url)
+    configuration = Worldline::Acquiring::SDK::CommunicatorConfiguration.new(properties: yaml,
+                                                                             api_endpoint: 'https://api.preprod.acquiring.worldline-solutions.com',
+                                                                             authorization_type: 'OAuth2',
+                                                                             oauth2_client_id: OAUTH2_CLIENT_ID,
+                                                                             oauth2_client_secret: OAUTH2_CLIENT_SECRET,
+                                                                             oauth2_token_uri: OAUTH2_TOKEN_URI,
+                                                                             max_connections: max_connections)
+    host = ENV['acquiring_api_endpoint_host']
+    if host
+      scheme = ENV.fetch('acquiring_api_endpoint_scheme', 'https')
+      port = ENV.fetch('acquiring_api_endpoint_port', -1)
+      configuration.api_endpoint = create_uri(scheme, host, port)
+    end
+    configuration
+  end
+
+  def self.init_client(with_proxy, max_connections = nil)
+    if with_proxy
+      url = PROPERTIES_URI_PROXY
+    else
+      url = PROPERTIES_URI_OAUTH2
+    end
+    configuration = init_communicator_configuration(properties_url: url, max_connections: max_connections)
+    yield client = Worldline::Acquiring::SDK::Factory.create_client_from_configuration(configuration)
+    client.close
+  end
+
+  def self.get_api_payment_request
+    request = Worldline::Acquiring::SDK::V1::Domain::ApiPaymentRequest.new
+
+    request.amount = Worldline::Acquiring::SDK::V1::Domain::AmountData.new
+    request.amount.amount = 200
+    request.amount.currency_code = 'GBP'
+    request.amount.number_of_decimals = 2
+    request.authorization_type = 'PRE_AUTHORIZATION'
+    request.transaction_timestamp = DateTime.now
+    request.card_payment_data = Worldline::Acquiring::SDK::V1::Domain::CardPaymentData.new
+    request.card_payment_data.card_entry_mode = 'ECOMMERCE'
+    request.card_payment_data.allow_partial_approval = false
+    request.card_payment_data.brand = 'VISA'
+    request.card_payment_data.capture_immediately = false
+    request.card_payment_data.cardholder_verification_method = 'CARD_SECURITY_CODE'
+    request.card_payment_data.card_data = Worldline::Acquiring::SDK::V1::Domain::PlainCardData.new
+    request.card_payment_data.card_data.expiry_date = '122031'
+    request.card_payment_data.card_data.card_number = '4176669999000104'
+    request.card_payment_data.card_data.card_security_code = '012'
+    request.references = Worldline::Acquiring::SDK::V1::Domain::PaymentReferences.new
+    request.references.merchant_reference = 'your-order-' + SecureRandom.uuid
+    request.operation_id = SecureRandom.uuid
+    request
+  end
+
+  def self.get_dcc_rate_request(amount = 200)
+    amount_data = Worldline::Acquiring::SDK::V1::Domain::AmountData.new
+    amount_data.amount = amount
+    amount_data.currency_code = 'GBP'
+    amount_data.number_of_decimals = 2
+
+    transaction_data_for_dcc = Worldline::Acquiring::SDK::V1::Domain::TransactionDataForDcc.new
+    transaction_data_for_dcc.amount = amount_data
+    transaction_data_for_dcc.transaction_type = 'PAYMENT'
+    transaction_data_for_dcc.transaction_timestamp = DateTime.now
+
+    point_of_sale_data_for_dcc = Worldline::Acquiring::SDK::V1::Domain::PointOfSaleDataForDcc.new
+    point_of_sale_data_for_dcc.terminal_id = '12345678'
+
+    card_data_for_dcc = Worldline::Acquiring::SDK::V1::Domain::CardDataForDcc.new
+    card_data_for_dcc.bin = '41766699'
+    card_data_for_dcc.brand = 'VISA'
+
+    request = Worldline::Acquiring::SDK::V1::Domain::GetDCCRateRequest.new
+    request.operation_id = SecureRandom.uuid
+    request.target_currency = 'EUR'
+    request.card_payment_data = card_data_for_dcc
+    request.point_of_sale_data = point_of_sale_data_for_dcc
+    request.transaction = transaction_data_for_dcc
+
+    request
+  end
+end

data/spec/lib/authentication/oauth2_authenticator_spec.rb

@@ -0,0 +1,68 @@
+require 'uri'
+require 'spec_helper'
+require 'securerandom'
+
+describe 'OAuth2Authenticator' do
+  resource_prefix = 'spec/fixtures/resources/authentication/'
+
+  OAuth2Exception = Worldline::Acquiring::SDK::Authentication::OAuth2Exception
+
+  before do
+    $configuration = Worldline::Acquiring::SDK::Factory.create_configuration(PROPERTIES_URI_OAUTH2,
+                                                                             SecureRandom.uuid,
+                                                                             SecureRandom.uuid)
+  end
+
+  it 'should retrieve the access token successfully' do
+    response_body = IO.read(resource_prefix + 'oauth2AccessToken.json')
+
+    stub_request(:post, $configuration.oauth2_token_uri)
+      .to_return(status: 200, body: response_body, headers: {'Content-Type' => 'application/json'})
+
+    authenticator = Worldline::Acquiring::SDK::Authentication::OAuth2Authenticator.new($configuration)
+    request_uri = URI::HTTP.build(path: '/operations')
+
+    runner_threads = Array.new(10){ Thread.new{
+        authenticator.get_authorization(nil, request_uri, nil)
+    }}
+    runner_threads.each { |t| expect(t.value).to eq('Bearer accessToken') }
+
+    assert_requested :post, $configuration.oauth2_token_uri, times: 1
+  end
+
+  it 'should fail with an invalid-client response' do
+    response_body = IO.read(resource_prefix + 'oauth2AccessToken.invalidClient.json')
+
+    stub_request(:post, $configuration.oauth2_token_uri)
+      .to_return(status: 401, body: response_body, headers: {'Content-Type' => 'application/json'})
+
+    authenticator = Worldline::Acquiring::SDK::Authentication::OAuth2Authenticator.new($configuration)
+    request_uri = URI::HTTP.build(path: '/operations')
+
+    runner_threads = Array.new(10){ Thread.new{
+      authenticator.get_authorization(nil, request_uri, nil)
+    }}
+    runner_threads.each { |t| expect{t.value}.to raise_error(OAuth2Exception) { |error|
+      expect(error.message).to eq('There was an error while retrieving the OAuth2 access token: unauthorized_client - INVALID_CREDENTIALS: Invalid client credentials');
+    }}
+
+    assert_requested :post, $configuration.oauth2_token_uri, times: runner_threads.length
+  end
+
+  it 'should retrieve the access token every time it is expired' do
+    response_body = IO.read(resource_prefix + 'oauth2AccessToken.expired.json')
+
+    stub_request(:post, $configuration.oauth2_token_uri)
+      .to_return(status: 200, body: response_body, headers: {'Content-Type' => 'application/json'})
+
+    authenticator = Worldline::Acquiring::SDK::Authentication::OAuth2Authenticator.new($configuration)
+    request_uri = URI::HTTP.build(path: '/operations')
+
+    runner_threads = Array.new(10){ Thread.new{
+      authenticator.get_authorization(nil, request_uri, nil)
+    }}
+    runner_threads.each { |t| expect(t.value).to eq('Bearer expiredAccessToken') }
+
+    assert_requested :post, $configuration.oauth2_token_uri, times: runner_threads.length
+  end
+end

data/spec/lib/client_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe 'Client' do
+  Factory ||= Worldline::Acquiring::SDK::Factory
+  Connection ||= Worldline::Acquiring::SDK::Communication::Connection
+  PooledConnection ||= Worldline::Acquiring::SDK::Communication::PooledConnection
+
+  it 'should not close idle connections of an unpooled connection' do
+    conn = Connection.allocate  # Create fake (uninitialized) connection
+    communicator = Factory.create_communicator_from_file(PROPERTIES_URI_OAUTH2, OAUTH2_CLIENT_ID, OAUTH2_CLIENT_SECRET, connection: conn)
+    client = Factory.create_client_from_communicator(communicator)
+
+    expect(communicator.instance_variable_get(:@connection)).to_not receive(:close_idle_connections)
+
+    client.close_idle_connections(0.500)
+  end
+
+  it 'should close idle connections of a pooled connection' do
+    conn = PooledConnection.allocate  # Create fake (uninitialized) connection
+    communicator = Factory.create_communicator_from_file(PROPERTIES_URI_OAUTH2, OAUTH2_CLIENT_ID, OAUTH2_CLIENT_SECRET, connection: conn)
+    client = Factory.create_client_from_communicator(communicator)
+
+    expect(communicator.instance_variable_get(:@connection)).to receive(:close_idle_connections).with(0.500)
+
+    client.close_idle_connections(0.500)
+  end
+
+  it 'should not close expired connections of an unpooled connection' do
+    conn = Connection.allocate  # Create fake (uninitialized) connection
+    communicator = Factory.create_communicator_from_file(PROPERTIES_URI_OAUTH2, OAUTH2_CLIENT_ID, OAUTH2_CLIENT_SECRET, connection: conn)
+    client = Factory.create_client_from_communicator(communicator)
+
+    expect(communicator.instance_variable_get(:@connection)).to_not receive(:close_expired_connections)
+
+    client.close_expired_connections
+  end
+
+  it 'should close expired connections of a pooled connection' do
+    conn = PooledConnection.allocate  # Create fake (uninitialized) connection
+    communicator = Factory.create_communicator_from_file(PROPERTIES_URI_OAUTH2, OAUTH2_CLIENT_ID, OAUTH2_CLIENT_SECRET, connection: conn)
+    client = Factory.create_client_from_communicator(communicator)
+
+    expect(communicator.instance_variable_get(:@connection)).to receive(:close_expired_connections)
+
+    client.close_expired_connections
+  end
+end