connect-sdk-ruby 1.0.0

data/spec/integration/token_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'integration_setup'
+require 'webmock/rspec'
+require 'ingenico/connect/sdk/domain/definitions/address'
+require 'ingenico/connect/sdk/domain/definitions/card_without_cvv'
+require 'ingenico/connect/sdk/domain/token/create_token_request'
+require 'ingenico/connect/sdk/domain/token/customer_token'
+require 'ingenico/connect/sdk/domain/token/token_card'
+require 'ingenico/connect/sdk/domain/token/token_card_data'
+require 'ingenico/connect/sdk/merchant/tokens/delete_token_params'
+
+describe 'token' do
+
+  before(:context){WebMock.allow_net_connect!}
+  after(:context){WebMock.disable_net_connect!}
+
+  it 'can be created and deleted' do
+    billing_address = Ingenico::Connect::SDK::Domain::Definitions::Address.new
+    billing_address.country_code = 'NL'
+    customer = Ingenico::Connect::SDK::Domain::Token::CustomerToken.new
+    customer.billing_address = billing_address
+    card_without_ccv = Ingenico::Connect::SDK::Domain::Definitions::CardWithoutCvv.new
+    card_without_ccv.cardholder_name = 'Jan'
+    card_without_ccv.issue_number = '12'
+    card_without_ccv.card_number = '4567350000427977'
+    card_without_ccv.expiry_date = '0820'
+    card_data = Ingenico::Connect::SDK::Domain::Token::TokenCardData.new
+    card_data.card_without_cvv = card_without_ccv
+    card = Ingenico::Connect::SDK::Domain::Token::TokenCard.new
+    card.customer = customer
+    card.data = card_data
+    create_token_request = Ingenico::Connect::SDK::Domain::Token::CreateTokenRequest.new
+    create_token_request.payment_product_id = 1
+    create_token_request.card = card
+
+    Integration.init_client(false) do |client|
+      token_response = client.merchant(Integration::MERCHANT_ID).tokens.create(create_token_request)
+      expect(token_response.token).to_not be_nil
+      client.merchant(Integration::MERCHANT_ID).tokens.delete(token_response.token, Ingenico::Connect::SDK::Merchant::Tokens::DeleteTokenParams.new)
+    end
+  end
+end

data/spec/integration_setup.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'yaml'
+
+module Integration
+  MERCHANT_ID = ENV['connect.api.merchantId']
+  API_KEY_ID = ENV['connect.api.apiKeyId']
+  SECRET_API_KEY = ENV['connect.api.secretApiKey']
+  raise 'could not access environment variable connect.api.merchantId required for testing' unless MERCHANT_ID
+  raise 'could not access environment variable connect.api.apiKeyId required for testing' unless API_KEY_ID
+  raise 'could not access environment variable connect.api.secretApiKey required for testing' unless SECRET_API_KEY
+  PROPERTIES_URI = File.absolute_path(File.join(__FILE__, '../fixtures/resources/properties.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, max_connections: nil)
+    yaml = YAML.load_file(properties_url)
+    configuration = Ingenico::Connect::SDK::CommunicatorConfiguration.new(properties: yaml,
+                                                       api_endpoint: 'https://api-sandbox.globalcollect.com',
+                                                       authorization_type: 'v1HMAC',
+                                                       api_key_id: API_KEY_ID,
+                                                       secret_api_key: SECRET_API_KEY,
+                                                       max_connections: max_connections)
+    host = ENV['connect.api.endpoint.host']
+    if host
+      scheme = ENV.fetch('connect.api.endpoint.scheme', 'https')
+      port = ENV.fetch('connect.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
+    end
+    yaml = YAML.load_file(url)
+    configuration = init_communicator_configuration(properties_url: url, max_connections: max_connections)
+    yield client = Ingenico::Connect::SDK::Factory.create_client_from_configuration(configuration).with_client_meta_info('{"test":"test"}')
+    client.close
+  end
+end

data/spec/lib/client_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe 'Client' do
+  Factory ||= Ingenico::Connect::SDK::Factory
+  Connection ||= Ingenico::Connect::SDK::Connection
+  PooledConnection ||= Ingenico::Connect::SDK::PooledConnection
+
+  it 'should return properly modified clients from *with_client_meta_info*' do
+    client1 = Factory.create_client_from_file(PROPERTIES_URI, API_KEY_ID, SECRET_API_KEY)
+    client2 = client1.with_client_meta_info(nil)
+    client_meta_info = Ingenico::Connect::SDK::DefaultImpl::DefaultMarshaller.INSTANCE.marshal({test: 'test'})
+    client3 = client1.with_client_meta_info(client_meta_info)
+    client4 = client3.with_client_meta_info(client_meta_info)
+    client5 = client3.with_client_meta_info(nil)
+
+
+    expect(client1.instance_variable_get(:@client_headers)).to be_nil
+    expect(client1).to be(client2)
+    expect(client1).to_not be(client3)
+    # Check if client3 has the meta_info stored
+    client3_info = client3.instance_variable_get(:@client_meta_info)
+    meta_info_encoded = Base64.strict_encode64(client_meta_info.encode('utf-8'))
+    expect(client3_info).to eq(meta_info_encoded)
+
+    expect(client3).to be(client4)
+    expect(client3).to_not be(client5)
+    expect(client5.instance_variable_get(:@client_headers)).to be_nil
+  end
+
+  it 'should not close idle connections of an unpooled connection' do
+    conn = Connection.allocate  # Create fake (uninitialized) connection
+    session = Factory.create_session_from_file(PROPERTIES_URI, API_KEY_ID, SECRET_API_KEY, connection: conn)
+    client = Factory.create_client_from_session(session)
+
+    expect(session.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
+    session = Factory.create_session_from_file(PROPERTIES_URI, API_KEY_ID, SECRET_API_KEY, connection: conn)
+    client = Factory.create_client_from_session(session)
+
+    expect(session.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
+    session = Factory.create_session_from_file(PROPERTIES_URI, API_KEY_ID, SECRET_API_KEY, connection: conn)
+    client = Factory.create_client_from_session(session)
+
+    expect(session.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
+    session = Factory.create_session_from_file(PROPERTIES_URI, API_KEY_ID, SECRET_API_KEY, connection: conn)
+    client = Factory.create_client_from_session(session)
+
+    expect(session.connection).to receive(:close_expired_connections)
+
+    client.close_expired_connections
+  end
+end

data/spec/lib/communicator_configuration_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+require 'yaml'
+
+CommunicatorConfiguration ||= Ingenico::Connect::SDK::CommunicatorConfiguration
+
+describe 'CommunicatorConfiguration' do
+
+  it 'can be constructed without a proxy' do
+    yaml = '---
+            connect.api.endpoint.host: api-sandbox.globalcollect.com
+            connect.api.authorizationType: v1HMAC
+            connect.api.connectTimeout: 20
+            connect.api.socketTimeout: 10'
+    config = YAML.load(yaml)
+
+    communicator_config = CommunicatorConfiguration.new(properties: config)
+
+    expect(communicator_config.api_endpoint).to eq('https://api-sandbox.globalcollect.com')
+    expect(communicator_config.authorization_type).to eq('v1HMAC')
+    expect(communicator_config.connect_timeout).to eq(20)
+    expect(communicator_config.socket_timeout).to eq(10)
+
+    expect(communicator_config.api_key_id).to be_nil
+    expect(communicator_config.secret_api_key).to be_nil
+    expect(communicator_config.proxy_configuration).to be_nil
+    expect(communicator_config.integrator).to be_nil
+    expect(communicator_config.shopping_cart_extension).to be_nil
+  end
+
+  it 'can be constructed with a proxy, without authentication' do
+    yaml = '---
+            connect.api.endpoint.host: api-sandbox.globalcollect.com
+            connect.api.authorizationType: v1HMAC
+            connect.api.connectTimeout: 20
+            connect.api.socketTimeout: 10
+            connect.api.proxy.uri: http://proxy.example.org:3128'
+    config = YAML.load(yaml)
+
+    communicator_config = CommunicatorConfiguration.new(properties: config)
+    proxy_config = communicator_config.proxy_configuration
+
+    expect(communicator_config.api_endpoint).to eq('https://api-sandbox.globalcollect.com')
+    expect(communicator_config.authorization_type).to eq('v1HMAC')
+    expect(communicator_config.connect_timeout).to eq(20)
+    expect(communicator_config.socket_timeout).to eq(10)
+
+    expect(communicator_config.api_key_id).to be_nil
+    expect(communicator_config.secret_api_key).to be_nil
+    expect(proxy_config).to be_truthy
+    expect(proxy_config.scheme).to eq('http')
+    expect(proxy_config.host).to eq('proxy.example.org')
+    expect(proxy_config.port).to eq(3128)
+    expect(proxy_config.username).to be_nil
+    expect(proxy_config.password).to be_nil
+  end
+
+  it 'can be constructed to authenticate to a proxy' do
+    yaml = '---
+            connect.api.endpoint.host: api-sandbox.globalcollect.com
+            connect.api.authorizationType: v1HMAC
+            connect.api.connectTimeout: 20
+            connect.api.socketTimeout: 10
+            connect.api.proxy.uri: http://proxy.example.org:3128
+            connect.api.proxy.username: global-collect-username
+            connect.api.proxy.password: global-collect-password'
+    config = YAML.load(yaml)
+
+    communicator_config = CommunicatorConfiguration.new(properties: config)
+    proxy_config = communicator_config.proxy_configuration
+
+    expect(communicator_config.api_endpoint).to eq('https://api-sandbox.globalcollect.com')
+    expect(communicator_config.authorization_type).to eq('v1HMAC')
+    expect(communicator_config.connect_timeout).to eq(20)
+    expect(communicator_config.socket_timeout).to eq(10)
+
+    expect(communicator_config.api_key_id).to be_nil
+    expect(communicator_config.secret_api_key).to be_nil
+    expect(proxy_config).to be_truthy
+    expect(proxy_config.scheme).to eq('http')
+    expect(proxy_config.host).to eq('proxy.example.org')
+    expect(proxy_config.port).to eq(3128)
+    expect(proxy_config.username).to eq('global-collect-username')
+    expect(proxy_config.password).to eq('global-collect-password')
+  end
+
+  it 'accepts a different number of maximum connections' do
+    yaml = '---
+            connect.api.endpoint.host: api-sandbox.globalcollect.com
+            connect.api.authorizationType: v1HMAC
+            connect.api.connectTimeout: 20
+            connect.api.socketTimeout: 10
+            connect.api.maxConnections: 100'
+    config = YAML.load(yaml)
+
+    communicator_config = CommunicatorConfiguration.new(properties: config)
+
+    expect(communicator_config.api_endpoint).to eq('https://api-sandbox.globalcollect.com')
+    expect(communicator_config.authorization_type).to eq('v1HMAC')
+    expect(communicator_config.connect_timeout).to eq(20)
+    expect(communicator_config.socket_timeout).to eq(10)
+    expect(communicator_config.max_connections).to eq(100)
+
+    expect(communicator_config.api_key_id).to be_nil
+    expect(communicator_config.secret_api_key).to be_nil
+    expect(communicator_config.proxy_configuration).to be_nil
+  end
+
+  it 'uses specific scheme to override default' do
+    yaml = '---
+            connect.api.endpoint.host: api-sandbox.globalcollect.com
+            connect.api.authorizationType: v1HMAC
+            connect.api.connectTimeout: 20
+            connect.api.socketTimeout: 10
+            connect.api.endpoint.scheme: http'
+    config = YAML.load(yaml)
+
+    communicator_config = CommunicatorConfiguration.new(properties: config)
+
+    expect(communicator_config.api_endpoint).to eq('http://api-sandbox.globalcollect.com')
+  end
+
+  it 'uses specific port to override default' do
+    yaml = '---
+            connect.api.endpoint.host: api-sandbox.globalcollect.com
+            connect.api.authorizationType: v1HMAC
+            connect.api.connectTimeout: 20
+            connect.api.socketTimeout: 10
+            connect.api.endpoint.port: 8080'
+    config = YAML.load(yaml)
+
+    communicator_config = CommunicatorConfiguration.new(properties: config)
+
+    expect(communicator_config.api_endpoint).to eq('https://api-sandbox.globalcollect.com:8080')
+  end
+
+  it 'uses specific scheme and port to override default' do
+    yaml = '---
+            connect.api.endpoint.host: api-sandbox.globalcollect.com
+            connect.api.authorizationType: v1HMAC
+            connect.api.connectTimeout: 20
+            connect.api.socketTimeout: 10
+            connect.api.endpoint.scheme: http
+            connect.api.endpoint.port: 8080'
+    config = YAML.load(yaml)
+
+    communicator_config = CommunicatorConfiguration.new(properties: config)
+
+    expect(communicator_config.api_endpoint).to eq('http://api-sandbox.globalcollect.com:8080')
+  end
+
+  it 'stores shoppingCartExtension data' do
+    yaml = '---
+            connect.api.endpoint.host: api-sandbox.globalcollect.com
+            connect.api.authorizationType: v1HMAC
+            connect.api.connectTimeout: 20
+            connect.api.socketTimeout: 10
+            connect.api.integrator: Ingenico.Integrator
+            connect.api.shoppingCartExtension.creator: Ingenico.Creator
+            connect.api.shoppingCartExtension.name: Ingenico.ShoppingCarts
+            connect.api.shoppingCartExtension.version: 1.0'
+    config = YAML.load(yaml)
+
+    communicator_config = CommunicatorConfiguration.new(properties: config)
+
+    expect(communicator_config.api_endpoint).to eq('https://api-sandbox.globalcollect.com')
+    expect(communicator_config.authorization_type).to eq('v1HMAC')
+    expect(communicator_config.connect_timeout).to eq(20)
+    expect(communicator_config.socket_timeout).to eq(10)
+
+    expect(communicator_config.api_key_id).to be_nil
+    expect(communicator_config.secret_api_key).to be_nil
+    expect(communicator_config.proxy_configuration).to be_nil
+    expect(communicator_config.integrator).to eq('Ingenico.Integrator')
+    expect(communicator_config.shopping_cart_extension).to be_truthy
+    expect(communicator_config.shopping_cart_extension.creator).to eq('Ingenico.Creator')
+    expect(communicator_config.shopping_cart_extension.name).to eq('Ingenico.ShoppingCarts')
+    expect(communicator_config.shopping_cart_extension.version).to eq('1.0')
+  end
+end

data/spec/lib/communicator_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'uri'
+
+Communicator ||= Ingenico::Connect::SDK::Communicator
+DefaultMarshaller ||= Ingenico::Connect::SDK::DefaultImpl::DefaultMarshaller
+RequestParam ||= Ingenico::Connect::SDK::RequestParam
+
+describe Communicator do
+
+  let(:session){instance_double('Session', :api_endpoint => URI('https://api-sandbox.globalcollect.com'))}
+  let(:communicator){communicator = Communicator.new(session, DefaultMarshaller.INSTANCE)}
+  context 'to_absolute_uri()' do
+    it 'accepts a uri with or without a leading slash' do
+      uri1 = communicator.send(:to_absolute_uri, 'v1/merchant/20000/convertamount', [])
+      uri2 = communicator.send(:to_absolute_uri, '/v1/merchant/20000/convertamount', [])
+      # Ruby URI library adds port in HTTPS url's by default
+      expect(uri1.to_s).to eq('https://api-sandbox.globalcollect.com:443/v1/merchant/20000/convertamount')
+      expect(uri2.to_s).to eq('https://api-sandbox.globalcollect.com:443/v1/merchant/20000/convertamount')
+    end
+
+    it 'adds request parameters to the uri' do
+      request_params = [RequestParam.new('amount', '123'), RequestParam.new('source', 'USD'),
+                        RequestParam.new('target', 'EUR'), RequestParam.new('dummy', 'é&%=')]
+
+      uri = communicator.send(:to_absolute_uri, 'v1/merchant/20000/convertamount', request_params)
+
+      expect(uri.to_s).to eq('https://api-sandbox.globalcollect.com:443/v1/merchant/20000/convertamount'\
+                             '?amount=123&source=USD&target=EUR&dummy=%C3%A9%26%25%3D')
+    end
+  end
+end

data/spec/lib/defaultimpl/default_authenticator_spec.rb

@@ -0,0 +1,74 @@
+require 'uri'
+require 'spec_helper'
+
+describe 'DefaultAuthenticator' do
+  RequestHeader ||= Ingenico::Connect::SDK::RequestHeader
+
+  let(:authenticator) {Ingenico::Connect::SDK::DefaultImpl::DefaultAuthenticator.new(
+      Ingenico::Connect::SDK::DefaultImpl::AuthorizationType.get_authorization('v1HMAC'), 'apiKeyId', 'secretApiKey')}
+
+  it 'should canonicalize headers' do
+    expect(authenticator.send(:to_canonical_header_value, "aap\nnoot  ")).to eq('aap noot')
+    expect(authenticator.send(:to_canonical_header_value, " aap\r\n  noot")).to eq('aap noot')
+  end
+
+  # Tests if a request can be converted to a canonical format to sign
+  it 'converts a request properly to signable data' do
+    http_headers = [RequestHeader.new('X-GCS-ServerMetaInfo',
+                                       '{"platformIdentifier":"Windows 7/6.1 Java/1.7 (Oracle Corporation; '+
+                                       'Java HotSpot(TM) 64-Bit Server VM; 1.7.0_45)","sdkIdentifier":"1.0"}'),
+                    RequestHeader.new('Content-Type', 'application/json'),
+                    RequestHeader.new('X-GCS-ClientMetaInfo', '{"aap","noot"}'),
+                    RequestHeader.new('User-Agent', 'Apache-HttpClient/4.3.4 (java 1.5)'),
+                    RequestHeader.new('Date', 'Mon, 07 Jul 2014 12:12:40 GMT')]
+
+    expected_start = "POST\n"+
+                     "application/json\n"
+    expected_end = %Q(x-gcs-clientmetainfo:{"aap","noot"}\n) +
+                   %Q(x-gcs-servermetainfo:{"platformIdentifier":"Windows 7/6.1 Java/1.7 )+
+                    %Q((Oracle Corporation; Java HotSpot(TM) 64-Bit Server VM; 1.7.0_45)",)+
+                    %Q("sdkIdentifier":"1.0"}\n)+
+                   %Q(/v1/9991/services%20bla/convert/amount?aap=noot&mies=geen%20noot\n)
+
+    data_to_sign = authenticator.send(:to_data_to_sign, 'POST',
+                           URI('http://localhost:8080/v1/9991/services%20bla/convert/amount?aap=noot&mies=geen%20noot'),
+                           http_headers)
+
+    # NOTE: Ruby has two types of range about end point:
+    # 1) inclusive: 0..1 => 0, 1
+    # 2) exclusive: 0...1 => 0
+    actual_start = data_to_sign[0...22]
+    actual_end = data_to_sign[52..-1]
+    expect(actual_start).to eq(expected_start)
+    expect(actual_end).to eq(expected_end)
+  end
+
+  context 'create_authentication_signature' do
+    it 'creates authentication signatures' do
+      data_to_sign = "DELETE\n"+
+          "application/json\n"+
+          "Fri, 06 Jun 2014 13:39:43 GMT\n"+
+          "x-gcs-clientmetainfo:processed header value\n"+
+          "x-gcs-customerheader:processed header value\n"+
+          "x-gcs-servermetainfo:processed header value\n"+
+          "/v1/9991/tokens/123456789\n"
+
+      authentication_signature = authenticator.send(:create_auth_signature, data_to_sign)
+
+      expect(authentication_signature).to eq('VfnXpPBQQoHZivTcAg0JvOWkhnzlPnaCPKpTQn/uMJM=')
+    end
+
+    it 'creates authentication signatures for more than one key' do
+      authenticator = Ingenico::Connect::SDK::DefaultImpl::DefaultAuthenticator.new(
+        Ingenico::Connect::SDK::DefaultImpl::AuthorizationType.get_authorization('v1HMAC'), 'apiKeyId', '6Kj5HT0MQKC6D8eb7W3lTg71kVKVDSt1')
+      data_to_sign = "GET\n"+
+                     "\n"+
+                     "Fri, 06 Jun 2014 13:39:43 GMT\n"+
+                     "/v1/9991/tokens/123456789\n"
+
+      authentication_signature = authenticator.send(:create_auth_signature, data_to_sign)
+
+      expect(authentication_signature).to eq('9ond5EIN05dBXJGCLRK5om9pxHsyrh/12pZJ7bvmwNM=')
+    end
+  end
+end