connect-sdk-ruby 2.47.1 → 3.0.0

data/spec/lib/communication/default_connection_spec.rb

@@ -0,0 +1,351 @@
+require 'spec_helper'
+require 'uri'
+require 'stringio'
+require 'sinatra'
+
+DefaultConnection ||= Worldline::Connect::SDK::Communication::DefaultConnection
+StdoutCommunicatorLogger ||= Worldline::Connect::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::Connect::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::Connect::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| Worldline::Connect::SDK::Communication::ResponseHeader.new(k, v) } }
+      let(:uri) { URI('http://foobar.com/v1/1234/services/convert/amount?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 '/convert_amount.json' do
+            content_type :json
+            IO.read(prefix + 'convertAmount.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/convert_amount.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 + 'convertAmount.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/communicator_configuration_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 require 'yaml'
 
-CommunicatorConfiguration ||= Ingenico::Connect::SDK::CommunicatorConfiguration
+CommunicatorConfiguration ||= Worldline::Connect::SDK::CommunicatorConfiguration
 
 describe 'CommunicatorConfiguration' do
 
   it 'can be constructed without a proxy' do
     yaml = '---
-            connect.api.endpoint.host: eu.sandbox.api-ingenico.com
+            connect.api.endpoint.host: api.preprod.connect.worldline-solutions.com
             connect.api.authorizationType: v1HMAC
             connect.api.connectTimeout: 20
             connect.api.socketTimeout: 10'
@@ -15,13 +15,13 @@ describe 'CommunicatorConfiguration' do
 
     communicator_config = CommunicatorConfiguration.new(properties: config)
 
-    expect(communicator_config.api_endpoint).to eq('https://eu.sandbox.api-ingenico.com')
+    expect(communicator_config.api_endpoint).to eq('https://api.preprod.connect.worldline-solutions.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.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
@@ -29,7 +29,7 @@ describe 'CommunicatorConfiguration' do
 
   it 'can be constructed with a proxy, without authentication' do
     yaml = '---
-            connect.api.endpoint.host: eu.sandbox.api-ingenico.com
+            connect.api.endpoint.host: api.preprod.connect.worldline-solutions.com
             connect.api.authorizationType: v1HMAC
             connect.api.connectTimeout: 20
             connect.api.socketTimeout: 10
@@ -39,13 +39,13 @@ describe 'CommunicatorConfiguration' do
     communicator_config = CommunicatorConfiguration.new(properties: config)
     proxy_config = communicator_config.proxy_configuration
 
-    expect(communicator_config.api_endpoint).to eq('https://eu.sandbox.api-ingenico.com')
+    expect(communicator_config.api_endpoint).to eq('https://api.preprod.connect.worldline-solutions.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.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')
@@ -56,7 +56,7 @@ describe 'CommunicatorConfiguration' do
 
   it 'can be constructed to authenticate to a proxy' do
     yaml = '---
-            connect.api.endpoint.host: eu.sandbox.api-ingenico.com
+            connect.api.endpoint.host: api.preprod.connect.worldline-solutions.com
             connect.api.authorizationType: v1HMAC
             connect.api.connectTimeout: 20
             connect.api.socketTimeout: 10
@@ -68,13 +68,13 @@ describe 'CommunicatorConfiguration' do
     communicator_config = CommunicatorConfiguration.new(properties: config)
     proxy_config = communicator_config.proxy_configuration
 
-    expect(communicator_config.api_endpoint).to eq('https://eu.sandbox.api-ingenico.com')
+    expect(communicator_config.api_endpoint).to eq('https://api.preprod.connect.worldline-solutions.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.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')
@@ -85,7 +85,7 @@ describe 'CommunicatorConfiguration' do
 
   it 'accepts a different number of maximum connections' do
     yaml = '---
-            connect.api.endpoint.host: eu.sandbox.api-ingenico.com
+            connect.api.endpoint.host: api.preprod.connect.worldline-solutions.com
             connect.api.authorizationType: v1HMAC
             connect.api.connectTimeout: 20
             connect.api.socketTimeout: 10
@@ -94,20 +94,20 @@ describe 'CommunicatorConfiguration' do
 
     communicator_config = CommunicatorConfiguration.new(properties: config)
 
-    expect(communicator_config.api_endpoint).to eq('https://eu.sandbox.api-ingenico.com')
+    expect(communicator_config.api_endpoint).to eq('https://api.preprod.connect.worldline-solutions.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.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 = '---
-            connect.api.endpoint.host: eu.sandbox.api-ingenico.com
+            connect.api.endpoint.host: api.preprod.connect.worldline-solutions.com
             connect.api.authorizationType: v1HMAC
             connect.api.connectTimeout: 20
             connect.api.socketTimeout: 10
@@ -116,12 +116,12 @@ describe 'CommunicatorConfiguration' do
 
     communicator_config = CommunicatorConfiguration.new(properties: config)
 
-    expect(communicator_config.api_endpoint).to eq('http://eu.sandbox.api-ingenico.com')
+    expect(communicator_config.api_endpoint).to eq('http://api.preprod.connect.worldline-solutions.com')
   end
 
   it 'uses specific port to override default' do
     yaml = '---
-            connect.api.endpoint.host: eu.sandbox.api-ingenico.com
+            connect.api.endpoint.host: api.preprod.connect.worldline-solutions.com
             connect.api.authorizationType: v1HMAC
             connect.api.connectTimeout: 20
             connect.api.socketTimeout: 10
@@ -130,12 +130,12 @@ describe 'CommunicatorConfiguration' do
 
     communicator_config = CommunicatorConfiguration.new(properties: config)
 
-    expect(communicator_config.api_endpoint).to eq('https://eu.sandbox.api-ingenico.com:8080')
+    expect(communicator_config.api_endpoint).to eq('https://api.preprod.connect.worldline-solutions.com:8080')
   end
 
   it 'uses specific scheme and port to override default' do
     yaml = '---
-            connect.api.endpoint.host: eu.sandbox.api-ingenico.com
+            connect.api.endpoint.host: api.preprod.connect.worldline-solutions.com
             connect.api.authorizationType: v1HMAC
             connect.api.connectTimeout: 20
             connect.api.socketTimeout: 10
@@ -145,36 +145,36 @@ describe 'CommunicatorConfiguration' do
 
     communicator_config = CommunicatorConfiguration.new(properties: config)
 
-    expect(communicator_config.api_endpoint).to eq('http://eu.sandbox.api-ingenico.com:8080')
+    expect(communicator_config.api_endpoint).to eq('http://api.preprod.connect.worldline-solutions.com:8080')
   end
 
   it 'stores shoppingCartExtension data' do
     yaml = '---
-            connect.api.endpoint.host: eu.sandbox.api-ingenico.com
+            connect.api.endpoint.host: api.preprod.connect.worldline-solutions.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.integrator: Worldline.Integrator
+            connect.api.shoppingCartExtension.creator: Worldline.Creator
+            connect.api.shoppingCartExtension.name: Worldline.ShoppingCarts
             connect.api.shoppingCartExtension.version: 1.0
             connect.api.shoppingCartExtension.extensionId: ExtensionId'
     config = YAML.load(yaml)
 
     communicator_config = CommunicatorConfiguration.new(properties: config)
 
-    expect(communicator_config.api_endpoint).to eq('https://eu.sandbox.api-ingenico.com')
+    expect(communicator_config.api_endpoint).to eq('https://api.preprod.connect.worldline-solutions.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.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('Ingenico.Integrator')
+    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('Ingenico.Creator')
-    expect(communicator_config.shopping_cart_extension.name).to eq('Ingenico.ShoppingCarts')
+    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

data/spec/lib/communicator_spec.rb

@@ -1,21 +1,24 @@
 require 'spec_helper'
 require 'uri'
 
-Communicator ||= Ingenico::Connect::SDK::Communicator
-DefaultMarshaller ||= Ingenico::Connect::SDK::DefaultImpl::DefaultMarshaller
-RequestParam ||= Ingenico::Connect::SDK::RequestParam
+Communicator ||= Worldline::Connect::SDK::Communicator
+Authenticator ||= Worldline::Connect::SDK::Authentication::Authenticator
+DefaultMarshaller ||= Worldline::Connect::SDK::JSON::DefaultMarshaller
+RequestParam ||= Worldline::Connect::SDK::Communication::RequestParam
 
 describe Communicator do
 
-  let(:session){instance_double('Session', :api_endpoint => URI('https://eu.sandbox.api-ingenico.com'))}
-  let(:communicator){communicator = Communicator.new(session, DefaultMarshaller.INSTANCE)}
+  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(URI('https://api.preprod.connect.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, '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://eu.sandbox.api-ingenico.com:443/v1/merchant/20000/convertamount')
-      expect(uri2.to_s).to eq('https://eu.sandbox.api-ingenico.com:443/v1/merchant/20000/convertamount')
+      expect(uri1.to_s).to eq('https://api.preprod.connect.worldline-solutions.com:443/v1/merchant/20000/convertamount')
+      expect(uri2.to_s).to eq('https://api.preprod.connect.worldline-solutions.com:443/v1/merchant/20000/convertamount')
     end
 
     it 'adds request parameters to the uri' do
@@ -24,7 +27,7 @@ describe Communicator do
 
       uri = communicator.send(:to_absolute_uri, 'v1/merchant/20000/convertamount', request_params)
 
-      expect(uri.to_s).to eq('https://eu.sandbox.api-ingenico.com:443/v1/merchant/20000/convertamount'\
+      expect(uri.to_s).to eq('https://api.preprod.connect.worldline-solutions.com:443/v1/merchant/20000/convertamount'\
                              '?amount=123&source=USD&target=EUR&dummy=%C3%A9%26%25%3D')
     end
   end

data/spec/lib/factory_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 require 'uri'
 
-Factory ||= Ingenico::Connect::SDK::Factory
+Factory ||= Worldline::Connect::SDK::Factory
 
 describe 'Factory' do
   it 'can initialize configurations' do
     configuration = Factory.create_configuration(PROPERTIES_URI, API_KEY_ID, SECRET_API_KEY)
 
-    expect(configuration.api_endpoint).to eq('https://eu.sandbox.api-ingenico.com')
+    expect(configuration.api_endpoint).to eq('https://api.preprod.connect.worldline-solutions.com')
     expect(configuration.authorization_type).to eq('v1HMAC')
     expect(configuration.connect_timeout).to eq(-1)
     expect(configuration.socket_timeout).to eq(-1)
@@ -19,19 +19,16 @@ describe 'Factory' do
 
   it 'can initialize communicators' do
     communicator = Factory.create_communicator_from_file(PROPERTIES_URI, API_KEY_ID, SECRET_API_KEY)
-    session = communicator.instance_variable_get(:@session)
-    connection = session.connection
-    authenticator = session.authenticator
-    meta_data_provider = session.meta_data_provider
-    request_headers = meta_data_provider.meta_data_headers
+    connection = communicator.instance_variable_get(:@connection)
+    authenticator = communicator.instance_variable_get(:@authenticator)
+    metadata_provider = communicator.instance_variable_get(:@metadata_provider)
+    request_headers = metadata_provider.metadata_headers
 
-    expect(communicator.marshaller).to be(Ingenico::Connect::SDK::DefaultImpl::DefaultMarshaller.INSTANCE)
-    expect(connection).to be_an_instance_of(Ingenico::Connect::SDK::DefaultImpl::DefaultConnection)
-    expect(authenticator).to be_an_instance_of(Ingenico::Connect::SDK::DefaultImpl::DefaultAuthenticator)
-    expect(meta_data_provider).to be_an_instance_of(Ingenico::Connect::SDK::MetaDataProvider)
+    expect(communicator.marshaller).to be(Worldline::Connect::SDK::JSON::DefaultMarshaller.instance)
+    expect(connection).to be_an_instance_of(Worldline::Connect::SDK::Communication::DefaultConnection)
+    expect(authenticator).to be_an_instance_of(Worldline::Connect::SDK::Authentication::V1HMACAuthenticator)
+    expect(metadata_provider).to be_an_instance_of(Worldline::Connect::SDK::Communication::MetadataProvider)
 
-    expect(authenticator.instance_variable_get(:@authorization_type))
-        .to eq(Ingenico::Connect::SDK::DefaultImpl::AuthorizationType.get_authorization('v1HMAC'))
     expect(authenticator.instance_variable_get(:@api_key_id)).to eq(API_KEY_ID)
     expect(authenticator.instance_variable_get(:@secret_api_key)).to eq(SECRET_API_KEY)
 

data/spec/lib/json/default_marshaller_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'worldline/connect/sdk/v1/domain/address'
+require 'worldline/connect/sdk/v1/domain/customer_token'
+require 'worldline/connect/sdk/v1/domain/token_card'
+require 'worldline/connect/sdk/v1/domain/token_card_data'
+require 'worldline/connect/sdk/v1/domain/token_response'
+
+DataObject ||= Worldline::Connect::SDK::Domain::DataObject
+DefaultMarshaller ||= Worldline::Connect::SDK::JSON::DefaultMarshaller
+Token ||= Worldline::Connect::SDK::V1::Domain
+
+class TokenResponseWithExtraField < Token::TokenResponse
+  attr_accessor :dummy
+end
+
+describe DefaultMarshaller do
+  context 'unmarshal()' do
+    it 'should unmarshal extra fields' do
+      token = TokenResponseWithExtraField.new
+      token.card = Token::TokenCard.new
+      token.card.customer = Token::CustomerToken.new
+      token.card.customer.billing_address = Worldline::Connect::SDK::V1::Domain::Address.new
+      token.card.customer.billing_address.country_code = 'NL'
+      token.card.data = Token::TokenCardData.new
+      token.dummy = 'foobar'
+      # marshal the extended token and unmarshal it as a regular token response
+      unmarshalled = DefaultMarshaller.instance.unmarshal(DefaultMarshaller.instance.marshal(token), Token::TokenResponse)
+
+      expect(unmarshalled.card).to_not be_nil
+      expect(unmarshalled.card.customer).to_not be_nil
+      expect(unmarshalled.card.customer.billing_address).to_not be_nil
+      expect(unmarshalled.card.customer.billing_address.country_code).to eq('NL')
+      expect(token.card.data).to_not be_nil
+    end
+  end
+end