acquiring-sdk-ruby 0.1.0

data/spec/lib/communication/default_connection_spec.rb

@@ -0,0 +1,352 @@
+require 'spec_helper'
+require 'uri'
+require 'stringio'
+require 'sinatra'
+
+DefaultConnection ||= Worldline::Acquiring::SDK::Communication::DefaultConnection
+ResponseHeader ||= Worldline::Acquiring::SDK::Communication::ResponseHeader
+StdoutCommunicatorLogger ||= Worldline::Acquiring::SDK::Logging::StdoutCommunicatorLogger
+
+describe DefaultConnection do
+  let(:connect_timeout) { 10 }
+  let(:socket_timeout) { 10 }
+  let(:max_connections) { 10 }
+  let(:proxy_configuration) { nil }
+  subject(:connection) do
+    described_class.new(connect_timeout: connect_timeout,
+                          socket_timeout: socket_timeout,
+                          max_connections: max_connections,
+                          proxy_configuration: proxy_configuration)
+  end
+
+  context 'construction' do
+    context 'without proxy' do
+      let(:proxy_configuration) { nil }
+      let(:max_connections) { nil }
+
+      it 'has the correct timeout values' do
+        expect(
+          connection.instance_variable_get(:@connect_timeout)
+        ).to eq(connect_timeout)
+
+        expect(
+          connection.instance_variable_get(:@socket_timeout)
+        ).to eq(socket_timeout)
+
+        expect(
+          connection.instance_variable_get(:@proxy_configuration)
+        ).to be_nil
+      end
+    end
+
+    context 'with proxy' do
+      let(:uri) { URI('http://test-proxy') }
+
+      context 'without authentication' do
+        let(:proxy_configuration) { Worldline::Acquiring::SDK::ProxyConfiguration.new(address: uri) }
+
+        it 'has the correct timeout values and proxy settings' do
+          expect(
+            connection.instance_variable_get(:@connect_timeout)
+          ).to eq(connect_timeout)
+
+          expect(
+            connection.instance_variable_get(:@socket_timeout)
+          ).to eq(socket_timeout)
+
+          expect(
+            connection.instance_variable_get(:@proxy_configuration).host
+          ).to eq('test-proxy')
+
+          expect(
+            connection.instance_variable_get(:@proxy_configuration).port
+          ).to eq(80)
+
+          expect(
+            connection.instance_variable_get(:@proxy_configuration).scheme
+          ).to eq('http')
+        end
+      end
+
+      context 'with authentication' do
+        let(:username) { 'test-username' }
+        let(:password) { 'test-password' }
+        let(:proxy_configuration) do
+          Worldline::Acquiring::SDK::ProxyConfiguration.new(address: uri,
+                                                            username: username,
+                                                            password: password)
+        end
+
+        it 'has the correct timeout values and proxy settings' do
+          expect(
+            connection.instance_variable_get(:@connect_timeout)
+          ).to eq(connect_timeout)
+
+          expect(
+            connection.instance_variable_get(:@socket_timeout)
+          ).to eq(socket_timeout)
+
+          pc = connection.instance_variable_get(:@proxy_configuration)
+
+          expect(pc.host).to eq('test-proxy')
+          expect(pc.port).to eq(80)
+          expect(pc.scheme).to eq('http')
+          expect(pc.username).to eq(username)
+          expect(pc.password).to eq(password)
+        end
+      end
+    end
+  end # construction
+
+  context 'sending and receiving' do
+
+    class DummyResponse
+      def pop
+        self
+      end
+
+      def status_code
+        200
+      end
+
+      def content
+        StringIO.new(body || '')
+      end
+
+      attr_accessor :headers, :body, :content_type, :uri
+    end
+
+    context 'without proxy' do
+      before :example do
+        # mock the HTTPClient obj inside DefaultConnection
+        # for each type of requests so no real requests will be made
+        client = connection.instance_variable_get(:@http_client)
+        allow(client).to receive(:get_async) do |uri, hash|
+          dummy_response = DummyResponse.new
+          dummy_response.headers = hash[:header]
+          dummy_response.uri = uri
+          dummy_response
+        end
+
+        allow(client).to receive(:delete_async) do |uri, hash|
+          dummy_response = DummyResponse.new
+          dummy_response.headers = hash[:header]
+          dummy_response.uri = uri
+          dummy_response
+        end
+
+        allow(client).to receive(:post_async) do |uri, hash|
+          dummy_response = DummyResponse.new
+          dummy_response.headers = hash[:header]
+          dummy_response.uri = uri
+          dummy_response.body = hash[:body]
+          dummy_response
+        end
+
+        allow(client).to receive(:put_async) do |uri, hash|
+          dummy_response = DummyResponse.new
+          dummy_response.headers = hash[:header]
+          dummy_response.uri = uri
+          dummy_response.body = hash[:body]
+          dummy_response
+        end
+
+        allow(client).to receive(:request_async) do |_method, uri, hash|
+          dummy_response = DummyResponse.new
+          dummy_response.headers = hash[:header]
+          dummy_response.uri = uri
+          dummy_response.body = hash[:body]
+          dummy_response
+        end
+      end
+
+      let(:headers) { { 'Content-Type' => 'application/json', 'header1' => 'dummy', 'header2' => 'yammy' } }
+      let(:sdk_headers) { headers.map {|k, v| ResponseHeader.new(k, v) } }
+      let(:uri) { URI('http://foobar.com/services/v1/100812/520000214/dcc-rates?source=EUR&amount=1000&target=USD') }
+
+      def expected_header_str(headers)
+        headers.inject('') { |str, (k, v)| %Q{#{str}#{k}="#{v}", }}.chomp(', ')
+      end
+
+      def sdk_headers_to_s(sdk_headers)
+        sdk_headers.inject('') { |s, h| s + h.name + ':' + h.value + ',' }
+      end
+
+      it 'sends the correct get request' do
+        response_headers = nil
+        connection.get(uri, sdk_headers) { |s, h, c| response_headers = h }
+        expect(sdk_headers_to_s(response_headers)).to eq(sdk_headers_to_s(sdk_headers))
+      end
+
+      it 'sends the correct delete request' do
+        response_headers = nil
+        connection.delete(uri, sdk_headers) { |s, h, c| response_headers = h }
+        expect(sdk_headers_to_s(response_headers)).to eq(sdk_headers_to_s(sdk_headers))
+      end
+
+      context 'with body' do
+        let(:body) { 'dummy body' }
+
+        it 'sends the correct post request' do
+          response_headers = nil
+          response_body = ''
+          connection.post(uri, sdk_headers, body) { |s, h, c| response_headers, response_body = h, c.read.force_encoding('UTF-8') }
+          expect(ResponseHeader.get_header_value(response_headers, 'Content-Type')).to eq('application/json')
+          expect(response_body).to eq(body)
+        end
+
+        it 'sends the correct put request' do
+          response_headers = nil
+          response_body = ''
+          connection.put(uri, sdk_headers, body) { |s, h, c| response_headers, response_body = h, c.read.force_encoding('UTF-8') }
+          expect(ResponseHeader.get_header_value(response_headers, 'Content-Type')).to eq('application/json')
+          expect(response_body).to eq(body)
+        end
+      end
+
+      context 'with logging' do
+        let(:logger) { StdoutCommunicatorLogger.instance }
+        let(:request_regex) do
+          # captures:
+          #   1) uuid
+          #   2) method
+          #   3) uri
+          #   4) headers
+          %r{\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2} Outgoing request \(requestId='([-a-zA-Z0-9]+)'\):
+  method:       '([A-Z]+)'
+  uri:          '(.+)'
+  headers:      '(.*)'}
+        end
+
+        let(:request_with_body_regex) do
+          # captures:
+          #   1) uuid
+          #   2) method
+          #   3) uri
+          #   4) headers
+          #   5) content_type
+          #   6) body
+          %r{\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2} Outgoing request \(requestId='([-a-zA-Z0-9]+)'\):
+  method:       '([A-Z]+)'
+  uri:          '(.+)'
+  headers:      '(.*)'
+  content-type: '(.+)'
+  body:         '(.+)'}
+        end
+
+        let(:response_regex) do
+          # captures:
+          #   1) status-cde
+          #   2) headers
+          #   3) content-type
+          #   4) body
+          %r{\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2} Incoming response \(requestId='([-a-zA-Z0-9]+)'.*\):
+  status-code:  '(\d+)'
+  headers:      '(.*)'
+  content-type: '(.*)'
+  body:         '(.*)'}
+        end
+
+        let(:regex) { Regexp.new(request_regex.to_s + "\n" + response_regex.to_s) }
+
+        let(:with_body_regex) do
+          Regexp.new(request_with_body_regex.to_s + "\n" + response_regex.to_s)
+        end
+
+        before :example do
+          $stdout = StringIO.new
+          connection.enable_logging(logger)
+        end
+
+        after :example do
+          connection.disable_logging
+          $stdout.close
+          $stdout = STDOUT
+        end
+
+        # TODO: DELETE is basically the same, do we need to test it?
+        it 'logs the correct get request' do
+          connection.get(uri, sdk_headers) { |s, h, c| }
+          expect($stdout.string).to match(regex)
+          match_info = $stdout.string.match(regex)
+          expect(match_info[2]).to eq('GET')
+          expect(match_info[3]).to eq(uri.path + '?' + uri.query)
+          expect(match_info[4]).to eq(expected_header_str(headers))
+        end
+
+        # TODO: same for PUT
+        context 'with body' do
+          let(:body) { 'dummy body' }
+          it 'logs the correct post request' do
+            connection.post(uri, sdk_headers, body) { |s, h, c| }
+            expect($stdout.string).to match(with_body_regex)
+            match_info = $stdout.string.match(with_body_regex)
+            expect(match_info[2]).to eq('POST')
+            expect(match_info[3]).to eq(uri.path + '?' + uri.query)
+            headers['Content-Type'] = 'application/json' # with body
+            expect(match_info[4]).to eq(expected_header_str(headers))
+            expect(match_info[5]).to eq('application/json')
+            expect(match_info[6]).to eq(body)
+          end
+        end
+      end
+    end
+  end # sending and receiving
+
+  context 'connection' do
+    server = nil
+    before :context do
+      WebMock.allow_net_connect!
+      server = Thread.new do
+        class DummyServer < Sinatra::Application
+          prefix = 'spec/fixtures/resources/communication/'
+
+          get '/get.json' do
+            content_type :json
+            IO.read(prefix + 'getWithQueryParams.json')
+          end
+
+          get '/' do
+            'testing'
+          end
+
+          run!
+        end
+      end
+      sleep 1 # wait for the server
+    end
+
+    after :context do
+      Thread.kill(server) # shutdown the server
+      WebMock.disable_net_connect!
+    end
+
+    before :example do
+      connection.close
+    end
+
+    let(:uri) { URI('http://localhost:4567/get.json') }
+    let(:sdk_headers) { [] }
+
+    it 'uses persistent connection if HTTP 1.1 is supported' do
+      100.times { connection.get(uri, sdk_headers) { |x, y| } }
+      expect(connection.session_count).to eq(1)
+    end
+
+    it 'retrieves the correct json file' do
+      response_body = ''
+      connection.get(uri, sdk_headers) { |status, headers, body| response_body = body.read.force_encoding('UTF-8') }
+      prefix = 'spec/fixtures/resources/communication/'
+      expect(response_body).to eq(IO.read(prefix + 'getWithQueryParams.json'))
+    end
+
+    it 'can explicitly close connections' do
+      connection.get(uri, sdk_headers) { |x, y| }
+
+      connection.close
+      expect(connection.session_count).to eq(0)
+
+      connection.get(uri, sdk_headers) { |x, y| }
+    end
+  end
+end

data/spec/lib/communication/metadata_provider_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+require 'worldline/acquiring/sdk/domain/shopping_cart_extension'
+require 'base64'
+
+describe 'MetadataProvider' do
+
+  MetadataProvider ||= Worldline::Acquiring::SDK::Communication::MetadataProvider
+  RequestHeader ||= Worldline::Acquiring::SDK::Communication::RequestHeader
+
+  it 'can give metadata_headers with a full shopping cart' do
+    shopping_cart_extension = Worldline::Acquiring::SDK::Domain::ShoppingCartExtension.new('Worldline.creator', 'Extension', '1.0', 'ExtensionId')
+    metadata_provider = MetadataProvider.new('Worldline', shopping_cart_extension: shopping_cart_extension)
+
+    request_headers = metadata_provider.metadata_headers
+    expect(request_headers.length).to eq(1)
+    expect(request_headers.length).to eq(1)
+
+    # Server meta info is stored in json format and encoded using utf-8 and base64
+    server_meta_info_json = Base64.strict_decode64(request_headers[0].value).force_encoding('utf-8')
+    server_meta_info = Worldline::Acquiring::SDK::JSON::DefaultMarshaller.instance.unmarshal(server_meta_info_json, MetadataProvider::ServerMetaInfo)
+
+    expect(server_meta_info.platform_identifier).to eq(metadata_provider.send(:get_platform_identifier))
+    expect(server_meta_info.sdk_identifier).to eq(metadata_provider.send(:get_sdk_identifier))
+    expect(server_meta_info.sdk_creator).to eq('Worldline')
+    expect(server_meta_info.shopping_cart_extension.creator).to eq(shopping_cart_extension.creator)
+    expect(server_meta_info.shopping_cart_extension.name).to eq(shopping_cart_extension.name)
+    expect(server_meta_info.shopping_cart_extension.version).to eq(shopping_cart_extension.version)
+    expect(server_meta_info.shopping_cart_extension.extension_id).to eq(shopping_cart_extension.extension_id)
+  end
+
+  it 'can give metadata_headers with a full shopping cart without an extension id' do
+    shopping_cart_extension = Worldline::Acquiring::SDK::Domain::ShoppingCartExtension.new('Worldline.creator', 'Extension', '1.0')
+    metadata_provider = MetadataProvider.new('Worldline', shopping_cart_extension: shopping_cart_extension)
+
+    request_headers = metadata_provider.metadata_headers
+    expect(request_headers.length).to eq(1)
+    expect(request_headers.length).to eq(1)
+
+    # Server meta info is stored in json format and encoded using utf-8 and base64
+    server_meta_info_json = Base64.strict_decode64(request_headers[0].value).force_encoding('utf-8')
+    server_meta_info = Worldline::Acquiring::SDK::JSON::DefaultMarshaller.instance.unmarshal(server_meta_info_json, MetadataProvider::ServerMetaInfo)
+
+    expect(server_meta_info.platform_identifier).to eq(metadata_provider.send(:get_platform_identifier))
+    expect(server_meta_info.sdk_identifier).to eq(metadata_provider.send(:get_sdk_identifier))
+    expect(server_meta_info.sdk_creator).to eq('Worldline')
+    expect(server_meta_info.shopping_cart_extension.creator).to eq(shopping_cart_extension.creator)
+    expect(server_meta_info.shopping_cart_extension.name).to eq(shopping_cart_extension.name)
+    expect(server_meta_info.shopping_cart_extension.version).to eq(shopping_cart_extension.version)
+    expect(server_meta_info.shopping_cart_extension.extension_id).to eq(shopping_cart_extension.extension_id)
+  end
+
+  it 'provides a server_meta_info header when no additional headers are provided' do
+    metadata_provider = MetadataProvider.new('Worldline')
+
+    request_headers = metadata_provider.metadata_headers
+    expect(request_headers.length).to eq(1)
+    expect(request_headers[0].name).to eq('X-WL-ServerMetaInfo')
+    expect(request_headers[0].value).to_not be_nil
+
+    # Server meta info is stored in json format and encoded using utf-8 and base64
+    server_meta_info_json = Base64.strict_decode64(request_headers[0].value).force_encoding('utf-8')
+    server_meta_info = Worldline::Acquiring::SDK::JSON::DefaultMarshaller.instance.unmarshal(server_meta_info_json, MetadataProvider::ServerMetaInfo)
+
+    expect(server_meta_info.platform_identifier).to eq(metadata_provider.send(:get_platform_identifier))
+    expect(server_meta_info.sdk_identifier).to eq(metadata_provider.send(:get_sdk_identifier))
+    expect(server_meta_info.sdk_creator).to eq('Worldline')
+  end
+
+  it 'provides a server_meta_info header and any additional headers provided' do
+    additional_headers = [RequestHeader.new('Header1', '&=$%'), RequestHeader.new('Header2', 'blah, blah'),
+                          RequestHeader.new('Header3', 'foo')]
+    metadata_provider = MetadataProvider.new('Worldline', additional_request_headers: additional_headers)
+    request_headers = metadata_provider.metadata_headers
+
+    expect(request_headers.length).to eq(4)
+
+    i = 1
+    additional_headers.each do |header|
+      expect(request_headers[i]).to eq(header)
+      i += 1
+    end
+  end
+
+  it 'refuses headers marked as prohibited' do
+    MetadataProvider.prohibited_headers.each do |name|
+      additional_headers = [RequestHeader.new('Header1', 'Value1'),
+                            RequestHeader.new(name, 'blood diamonds'),
+                            RequestHeader.new('Header3', 'Value3')]
+      expect{MetadataProvider.new('Worldline', additional_request_headers: additional_headers)}
+          .to raise_error{|error| expect(error.message).to include(name)}
+    end
+  end
+end

data/spec/lib/communicator_configuration_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+require 'yaml'
+
+CommunicatorConfiguration ||= Worldline::Acquiring::SDK::CommunicatorConfiguration
+
+describe 'CommunicatorConfiguration' do
+
+  it 'can be constructed without a proxy' do
+    yaml = '---
+            acquiring.api.endpoint.host: api.preprod.acquiring.worldline-solutions.com
+            acquiring.api.authorizationType: OAuth2
+            acquiring.api.connectTimeout: 20
+            acquiring.api.socketTimeout: 10'
+    config = YAML.load(yaml)
+
+    communicator_config = CommunicatorConfiguration.new(properties: config)
+
+    expect(communicator_config.api_endpoint).to eq('https://api.preprod.acquiring.worldline-solutions.com')
+    expect(communicator_config.authorization_type).to eq('OAuth2')
+    expect(communicator_config.connect_timeout).to eq(20)
+    expect(communicator_config.socket_timeout).to eq(10)
+
+    expect(communicator_config.authorization_id).to be_nil
+    expect(communicator_config.authorization_secret).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 = '---
+            acquiring.api.endpoint.host: api.preprod.acquiring.worldline-solutions.com
+            acquiring.api.authorizationType: OAuth2
+            acquiring.api.connectTimeout: 20
+            acquiring.api.socketTimeout: 10
+            acquiring.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.preprod.acquiring.worldline-solutions.com')
+    expect(communicator_config.authorization_type).to eq('OAuth2')
+    expect(communicator_config.connect_timeout).to eq(20)
+    expect(communicator_config.socket_timeout).to eq(10)
+
+    expect(communicator_config.authorization_id).to be_nil
+    expect(communicator_config.authorization_secret).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 = '---
+            acquiring.api.endpoint.host: api.preprod.acquiring.worldline-solutions.com
+            acquiring.api.authorizationType: OAuth2
+            acquiring.api.connectTimeout: 20
+            acquiring.api.socketTimeout: 10
+            acquiring.api.proxy.uri: http://proxy.example.org:3128
+            acquiring.api.proxy.username: test-username
+            acquiring.api.proxy.password: test-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.preprod.acquiring.worldline-solutions.com')
+    expect(communicator_config.authorization_type).to eq('OAuth2')
+    expect(communicator_config.connect_timeout).to eq(20)
+    expect(communicator_config.socket_timeout).to eq(10)
+
+    expect(communicator_config.authorization_id).to be_nil
+    expect(communicator_config.authorization_secret).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('test-username')
+    expect(proxy_config.password).to eq('test-password')
+  end
+
+  it 'accepts a different number of maximum connections' do
+    yaml = '---
+            acquiring.api.endpoint.host: api.preprod.acquiring.worldline-solutions.com
+            acquiring.api.authorizationType: OAuth2
+            acquiring.api.connectTimeout: 20
+            acquiring.api.socketTimeout: 10
+            acquiring.api.maxConnections: 100'
+    config = YAML.load(yaml)
+
+    communicator_config = CommunicatorConfiguration.new(properties: config)
+
+    expect(communicator_config.api_endpoint).to eq('https://api.preprod.acquiring.worldline-solutions.com')
+    expect(communicator_config.authorization_type).to eq('OAuth2')
+    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.authorization_id).to be_nil
+    expect(communicator_config.authorization_secret).to be_nil
+    expect(communicator_config.proxy_configuration).to be_nil
+  end
+
+  it 'uses specific scheme to override default' do
+    yaml = '---
+            acquiring.api.endpoint.host: api.preprod.acquiring.worldline-solutions.com
+            acquiring.api.authorizationType: OAuth2
+            acquiring.api.connectTimeout: 20
+            acquiring.api.socketTimeout: 10
+            acquiring.api.endpoint.scheme: http'
+    config = YAML.load(yaml)
+
+    communicator_config = CommunicatorConfiguration.new(properties: config)
+
+    expect(communicator_config.api_endpoint).to eq('http://api.preprod.acquiring.worldline-solutions.com')
+  end
+
+  it 'uses specific port to override default' do
+    yaml = '---
+            acquiring.api.endpoint.host: api.preprod.acquiring.worldline-solutions.com
+            acquiring.api.authorizationType: OAuth2
+            acquiring.api.connectTimeout: 20
+            acquiring.api.socketTimeout: 10
+            acquiring.api.endpoint.port: 8080'
+    config = YAML.load(yaml)
+
+    communicator_config = CommunicatorConfiguration.new(properties: config)
+
+    expect(communicator_config.api_endpoint).to eq('https://api.preprod.acquiring.worldline-solutions.com:8080')
+  end
+
+  it 'uses specific scheme and port to override default' do
+    yaml = '---
+            acquiring.api.endpoint.host: api.preprod.acquiring.worldline-solutions.com
+            acquiring.api.authorizationType: OAuth2
+            acquiring.api.connectTimeout: 20
+            acquiring.api.socketTimeout: 10
+            acquiring.api.endpoint.scheme: http
+            acquiring.api.endpoint.port: 8080'
+    config = YAML.load(yaml)
+
+    communicator_config = CommunicatorConfiguration.new(properties: config)
+
+    expect(communicator_config.api_endpoint).to eq('http://api.preprod.acquiring.worldline-solutions.com:8080')
+  end
+
+  it 'stores shoppingCartExtension data' do
+    yaml = '---
+            acquiring.api.endpoint.host: api.preprod.acquiring.worldline-solutions.com
+            acquiring.api.authorizationType: OAuth2
+            acquiring.api.connectTimeout: 20
+            acquiring.api.socketTimeout: 10
+            acquiring.api.integrator: Worldline.Integrator
+            acquiring.api.shoppingCartExtension.creator: Worldline.Creator
+            acquiring.api.shoppingCartExtension.name: Worldline.ShoppingCarts
+            acquiring.api.shoppingCartExtension.version: 1.0
+            acquiring.api.shoppingCartExtension.extensionId: ExtensionId'
+    config = YAML.load(yaml)
+
+    communicator_config = CommunicatorConfiguration.new(properties: config)
+
+    expect(communicator_config.api_endpoint).to eq('https://api.preprod.acquiring.worldline-solutions.com')
+    expect(communicator_config.authorization_type).to eq('OAuth2')
+    expect(communicator_config.connect_timeout).to eq(20)
+    expect(communicator_config.socket_timeout).to eq(10)
+
+    expect(communicator_config.authorization_id).to be_nil
+    expect(communicator_config.authorization_secret).to be_nil
+    expect(communicator_config.proxy_configuration).to be_nil
+    expect(communicator_config.integrator).to eq('Worldline.Integrator')
+    expect(communicator_config.shopping_cart_extension).to be_truthy
+    expect(communicator_config.shopping_cart_extension.creator).to eq('Worldline.Creator')
+    expect(communicator_config.shopping_cart_extension.name).to eq('Worldline.ShoppingCarts')
+    expect(communicator_config.shopping_cart_extension.version).to eq('1.0')
+    expect(communicator_config.shopping_cart_extension.extension_id).to eq('ExtensionId')
+  end
+end

data/spec/lib/communicator_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'uri'
+
+Communicator ||= Worldline::Acquiring::SDK::Communicator
+Authenticator ||= Worldline::Acquiring::SDK::Authentication::Authenticator
+DefaultMarshaller ||= Worldline::Acquiring::SDK::JSON::DefaultMarshaller
+RequestParam ||= Worldline::Acquiring::SDK::Communication::RequestParam
+
+describe Communicator do
+
+  let(:conn){conn = Connection.allocate} # Create fake (uninitialized) connection
+  let(:auth){auth = Authenticator.allocate} # Create fake (uninitialized) authenticator
+  let(:metadataProvider){metadata_provider = MetadataProvider.new("Worldline")}
+  let(:communicator){communicator = Communicator.new('https://api.preprod.acquiring.worldline-solutions.com', conn, auth, metadataProvider, DefaultMarshaller.instance)}
+  context 'to_absolute_uri()' do
+    it 'accepts a uri with or without a leading slash' do
+      uri1 = communicator.send(:to_absolute_uri, 'services/v1/100812/520000214/dcc-rates', [])
+      uri2 = communicator.send(:to_absolute_uri, '/services/v1/100812/520000214/dcc-rates', [])
+      # Ruby URI library adds port in HTTPS url's by default
+      expect(uri1.to_s).to eq('https://api.preprod.acquiring.worldline-solutions.com:443/services/v1/100812/520000214/dcc-rates')
+      expect(uri2.to_s).to eq('https://api.preprod.acquiring.worldline-solutions.com:443/services/v1/100812/520000214/dcc-rates')
+    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, 'services/v1/100812/520000214/dcc-rates', request_params)
+
+      expect(uri.to_s).to eq('https://api.preprod.acquiring.worldline-solutions.com:443/services/v1/100812/520000214/dcc-rates'\
+                             '?amount=123&source=USD&target=EUR&dummy=%C3%A9%26%25%3D')
+    end
+  end
+end