connect-sdk-ruby 2.47.1 → 3.0.0

data/spec/lib/logging/obfuscation/body_obfuscator_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-BodyObfuscator = Ingenico::Connect::SDK::Logging::Obfuscation::BodyObfuscator
+BodyObfuscator = Worldline::Connect::SDK::Logging::Obfuscation::BodyObfuscator
 
 def test_obfuscate_body_with_matches(original_resource, obfuscated_resource,
                                      body_obfuscator=BodyObfuscator.default_obfuscator)

data/spec/lib/logging/obfuscation/header_obfuscator_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-HeaderObfuscator = Ingenico::Connect::SDK::Logging::Obfuscation::HeaderObfuscator
-Obfuscation = Ingenico::Connect::SDK::Logging::Obfuscation
+HeaderObfuscator = Worldline::Connect::SDK::Logging::Obfuscation::HeaderObfuscator
+Obfuscation = Worldline::Connect::SDK::Logging::Obfuscation
 
 def test_obfuscate_header_with_match(name, original_value, expected_value,
                                      header_obfuscator=HeaderObfuscator.default_obfuscator)

data/spec/lib/logging/ruby_communicator_logger_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'logger'
 require 'English'
 
-RubyCommunicatorLogger = Ingenico::Connect::SDK::Logging::RubyCommunicatorLogger
+RubyCommunicatorLogger = Worldline::Connect::SDK::Logging::RubyCommunicatorLogger
 
 describe RubyCommunicatorLogger do
 
@@ -34,7 +34,7 @@ describe RubyCommunicatorLogger do
       let(:tag) { 'I' }
 
       it 'should not throw an exception when logging unicode strings' do
-        message =  ResponseLogMessageBuilder.new("aaa", 2345, 45.32)
+        message =  Worldline::Connect::SDK::Logging::ResponseLogMessageBuilder.new("aaa", 2345, 45.32)
         body = "Schröder"
         content = "JSON"
         message.set_body(body, content)

data/spec/lib/logging/stdout_communicator_logger_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'English'
 
-StdoutCommunicatorLogger ||= Ingenico::Connect::SDK::Logging::StdoutCommunicatorLogger
+StdoutCommunicatorLogger ||= Worldline::Connect::SDK::Logging::StdoutCommunicatorLogger
 
 describe StdoutCommunicatorLogger do
   before do
@@ -13,7 +13,7 @@ describe StdoutCommunicatorLogger do
     $stdout = STDOUT
   end
 
-  subject(:sample) { StdoutCommunicatorLogger.INSTANCE }
+  subject(:sample) { StdoutCommunicatorLogger.instance }
   let(:regex) do
     Regexp.new("\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2} (.*)#{$RS}",
                Regexp::MULTILINE)

data/spec/lib/metadata_provider_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+require 'worldline/connect/sdk/domain/shopping_cart_extension'
+require 'base64'
+
+describe 'MetadataProvider' do
+
+  MetadataProvider ||= Worldline::Connect::SDK::Communication::MetadataProvider
+  RequestHeader ||= Worldline::Connect::SDK::Communication::RequestHeader
+
+  it 'can give metadata_headers with a full shopping cart' do
+    shopping_cart_extension = Worldline::Connect::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::Connect::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::Connect::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::Connect::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-GCS-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::Connect::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/payments_client_spec.rb

@@ -1,23 +1,22 @@
 require 'spec_helper'
-require 'ingenico/connect/sdk/domain/definitions/card'
-require 'ingenico/connect/sdk/domain/payment/card_payment_method_specific_input'
-require 'ingenico/connect/sdk/domain/payment/create_payment_request'
-require 'ingenico/connect/sdk/domain/payment/customer'
-require 'ingenico/connect/sdk/domain/payment/order'
-require 'ingenico/connect/sdk/merchant/payments/payments_client'
-
-PaymentsClient ||= Ingenico::Connect::SDK::Merchant::Payments::PaymentsClient
-Payment ||= Ingenico::Connect::SDK::Domain::Payment
-Definitions ||= Ingenico::Connect::SDK::Domain::Definitions
-ResponseHeader ||= Ingenico::Connect::SDK::ResponseHeader
-
-ResponseException ||= Ingenico::Connect::SDK::ResponseException
-CommunicationException ||= Ingenico::Connect::SDK::CommunicationException
-ApiException ||= Ingenico::Connect::SDK::ApiException
-ValidationException ||= Ingenico::Connect::SDK::ValidationException
-DeclinedPaymentException ||= Ingenico::Connect::SDK::DeclinedPaymentException
-ReferenceException ||= Ingenico::Connect::SDK::ReferenceException
-IdempotenceException ||= Ingenico::Connect::SDK::IdempotenceException
+require 'worldline/connect/sdk/v1/domain/card'
+require 'worldline/connect/sdk/v1/domain/card_payment_method_specific_input'
+require 'worldline/connect/sdk/v1/domain/create_payment_request'
+require 'worldline/connect/sdk/v1/domain/customer'
+require 'worldline/connect/sdk/v1/domain/order'
+require 'worldline/connect/sdk/v1/merchant/payments/payments_client'
+
+PaymentsClient ||= Worldline::Connect::SDK::V1::Merchant::Payments::PaymentsClient
+Domain ||= Worldline::Connect::SDK::V1::Domain
+ResponseHeader ||= Worldline::Connect::SDK::Communication::ResponseHeader
+
+ResponseException ||= Worldline::Connect::SDK::Communication::ResponseException
+CommunicationException ||= Worldline::Connect::SDK::Communication::CommunicationException
+ApiException ||= Worldline::Connect::SDK::V1::ApiException
+ValidationException ||= Worldline::Connect::SDK::V1::ValidationException
+DeclinedPaymentException ||= Worldline::Connect::SDK::V1::DeclinedPaymentException
+ReferenceException ||= Worldline::Connect::SDK::V1::ReferenceException
+IdempotenceException ||= Worldline::Connect::SDK::V1::IdempotenceException
 
 describe PaymentsClient do
 
@@ -25,24 +24,24 @@ describe PaymentsClient do
   let(:request_body) {create_resource}
 
   it 'can create payments' do
-    connection = double(Ingenico::Connect::SDK::Connection)
+    connection = double(Worldline::Connect::SDK::Communication::Connection)
     client = init_client(connection)
     response_body = IO.read(resource_prefix + 'pending_approval.json')
     allow(connection).to receive(:post).and_yield(201, {}, StringIO.new(response_body))
 
-    response = client.merchant('merchantId').payments.create(request_body)
+    response = client.v1.merchant('merchantId').payments.create(request_body)
 
     expect(response.payment.id).to eq('000002000020142549460000100001')
     expect(response.payment.status).to eq('PENDING_APPROVAL')
   end
 
   it 'can deal with rejection' do
-    connection = double(Ingenico::Connect::SDK::Connection)
+    connection = double(Worldline::Connect::SDK::Communication::Connection)
     client = init_client(connection)
     response_body = IO.read(resource_prefix + 'rejected.json')
     allow(connection).to receive(:post).and_yield(400, {}, StringIO.new(response_body))
 
-    expect{client.merchant('merchantId').payments.create(request_body)}.to raise_error(DeclinedPaymentException){|error|
+    expect{client.v1.merchant('merchantId').payments.create(request_body)}.to raise_error(DeclinedPaymentException){|error|
       expect(error.message).to include("payment '000002000020142544360000100001'")
       expect(error.message).to include("status 'REJECTED'")
       expect(error.message).to include(response_body)
@@ -53,47 +52,47 @@ describe PaymentsClient do
   end
 
   it 'can deal with invalid requests' do
-    connection = double(Ingenico::Connect::SDK::Connection)
+    connection = double(Worldline::Connect::SDK::Communication::Connection)
     client = init_client(connection)
     response_body = IO.read(resource_prefix + 'invalid_request.json')
     allow(connection).to receive(:post).and_yield(400, {}, StringIO.new(response_body))
 
-    expect{client.merchant('merchantId').payments.create(request_body)}.to raise_error(ValidationException){|error|
+    expect{client.v1.merchant('merchantId').payments.create(request_body)}.to raise_error(ValidationException){|error|
       expect(error.message).to include(response_body)
     }
   end
 
   it 'can deal with not being authorized' do
-    connection = double(Ingenico::Connect::SDK::Connection)
+    connection = double(Worldline::Connect::SDK::Communication::Connection)
     client = init_client(connection)
     response_body = IO.read(resource_prefix + 'invalid_authorization.json')
     allow(connection).to receive(:post).and_yield(401, {}, StringIO.new(response_body))
 
-    expect{client.merchant('merchantId').payments.create(request_body)}.to raise_error(ApiException){|error|
+    expect{client.v1.merchant('merchantId').payments.create(request_body)}.to raise_error(ApiException){|error|
 
       expect(error.message).to include(response_body)
     }
   end
 
   it 'can handle the payment already existing' do
-    connection = double(Ingenico::Connect::SDK::Connection)
+    connection = double(Worldline::Connect::SDK::Communication::Connection)
     client = init_client(connection)
     response_body = IO.read(resource_prefix + 'duplicate_request.json')
     allow(connection).to receive(:post).and_yield(409, {}, StringIO.new(response_body))
 
-    expect{client.merchant('merchantId').payments.create(request_body)}.to raise_error(ReferenceException){|error|
+    expect{client.v1.merchant('merchantId').payments.create(request_body)}.to raise_error(ReferenceException){|error|
       expect(error.message).to include(response_body)
     }
   end
 
   it 'can deal with sending a request twice' do
-    connection = double(Ingenico::Connect::SDK::Connection)
+    connection = double(Worldline::Connect::SDK::Communication::Connection)
     client = init_client(connection)
     response_body = IO.read(resource_prefix + 'duplicate_request.json')
-    context = Ingenico::Connect::SDK::CallContext.new('key')
+    context = Worldline::Connect::SDK::CallContext.new('key')
     allow(connection).to receive(:post).and_yield(409, {}, StringIO.new(response_body))
 
-    expect{client.merchant('merchantId').payments.create(request_body, context)}
+    expect{client.v1.merchant('merchantId').payments.create(request_body, context)}
         .to raise_error(IdempotenceException){|error|
           expect(error.message).to include(response_body)
           expect(error.idempotence_key).to eq(context.idempotence_key)
@@ -101,55 +100,55 @@ describe PaymentsClient do
   end
 
   it 'can handle its client not being found' do
-    connection = double(Ingenico::Connect::SDK::Connection)
+    connection = double(Worldline::Connect::SDK::Communication::Connection)
     client = init_client(connection)
     response_body = IO.read(resource_prefix + 'not_found.html')
     allow(connection).to receive(:post).and_yield(404, [ResponseHeader.new('content-type', 'text/html')], StringIO.new(response_body))
 
-    expect{client.merchant('merchantId').payments.create(request_body)}.to raise_error(Ingenico::Connect::SDK::NotFoundException){|error|
+    expect{client.v1.merchant('merchantId').payments.create(request_body)}.to raise_error(Worldline::Connect::SDK::Communication::NotFoundException){|error|
       expect(error.cause).to be_a(ResponseException)
       expect(error.cause.message).to include(response_body)
     }
   end
 
   it 'can handle the server misbehaving' do
-    connection = double(Ingenico::Connect::SDK::Connection)
+    connection = double(Worldline::Connect::SDK::Communication::Connection)
     client = init_client(connection)
     response_body = IO.read(resource_prefix + 'method_not_allowed.html')
     allow(connection).to receive(:post).and_yield(405, [ResponseHeader.new('content-type', 'text/html')], StringIO.new(response_body))
 
-    expect{client.merchant('merchantId').payments.create(request_body)}.to raise_error(CommunicationException){|error|
+    expect{client.v1.merchant('merchantId').payments.create(request_body)}.to raise_error(CommunicationException){|error|
       expect(error.cause).to be_a(ResponseException)
       expect(error.cause.message).to include(response_body)
     }
   end
 
   def init_client(connection)
-    session = Ingenico::Connect::SDK::Session.new('http://localhost', connection,
-                               Ingenico::Connect::SDK::DefaultImpl::DefaultAuthenticator.new(
-                                   Ingenico::Connect::SDK::DefaultImpl::AuthorizationType.get_authorization('v1HMAC'), 'admin', 'admin'),
-                               Ingenico::Connect::SDK::MetaDataProvider.new('Ingenico'))
-    return Ingenico::Connect::SDK::Factory.create_client_from_session(session)
+    communicator = Worldline::Connect::SDK::Communicator.new('http://localhost', connection,
+                               Worldline::Connect::SDK::Authentication::V1HMACAuthenticator.new('admin', 'admin'),
+                               Worldline::Connect::SDK::Communication::MetadataProvider.new('Worldline'),
+                               Worldline::Connect::SDK::JSON::DefaultMarshaller.instance)
+    return Worldline::Connect::SDK::Factory.create_client_from_communicator(communicator)
   end
 
   def create_resource
-    amount_of_money = Definitions::AmountOfMoney.new
+    amount_of_money = Domain::AmountOfMoney.new
     amount_of_money.amount = 2345
     amount_of_money.currency_code = 'CAD'
-    customer = Payment::Customer.new
-    billing_address = Definitions::Address.new
+    customer = Domain::Customer.new
+    billing_address = Domain::Address.new
     billing_address.country_code = 'CA'
     customer.billing_address = billing_address
-    order = Payment::Order.new
+    order = Domain::Order.new
     order.customer = customer
-    card = Definitions::Card.new
+    card = Domain::Card.new
     card.cvv = '123'
     card.card_number = '4567350000427977'
     card.expiry_date = '1220'
-    card_payment_method_specific_input = Payment::CardPaymentMethodSpecificInput.new
+    card_payment_method_specific_input = Domain::CardPaymentMethodSpecificInput.new
     card_payment_method_specific_input.card = card
     card_payment_method_specific_input.payment_product_id = 1
-    body = Payment::CreatePaymentRequest.new
+    body = Domain::CreatePaymentRequest.new
     body.card_payment_method_specific_input = card_payment_method_specific_input
     body
   end

data/spec/lib/requestparams/delete_params_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
-require 'ingenico/connect/sdk/merchant/tokens/delete_token_params'
+require 'worldline/connect/sdk/v1/merchant/tokens/delete_token_params'
 
-DeleteTokenParams ||= Ingenico::Connect::SDK::Merchant::Tokens::DeleteTokenParams
-RequestParam ||= Ingenico::Connect::SDK::RequestParam
+DeleteTokenParams ||= Worldline::Connect::SDK::V1::Merchant::Tokens::DeleteTokenParams
+RequestParam ||= Worldline::Connect::SDK::Communication::RequestParam
 
 describe 'DeleteTokenParams' do
 

data/spec/lib/requestparams/directory_params_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
-require 'ingenico/connect/sdk/merchant/products/directory_params'
+require 'worldline/connect/sdk/v1/merchant/products/directory_params'
 
 describe 'DirectoryParams' do
-  subject(:params){Ingenico::Connect::SDK::Merchant::Products::DirectoryParams.new}
+  subject(:params){Worldline::Connect::SDK::V1::Merchant::Products::DirectoryParams.new}
 
   it 'should output an empty list when no parameters are present' do
     expect(params.to_request_parameters).to eq([])
@@ -11,7 +11,8 @@ describe 'DirectoryParams' do
   it 'accepts parameters' do
     params.country_code = 'NL'
     params.currency_code = 'EUR'
-    expected = [Ingenico::Connect::SDK::RequestParam.new('countryCode', 'NL'), Ingenico::Connect::SDK::RequestParam.new('currencyCode', 'EUR')]
+    expected = [Worldline::Connect::SDK::Communication::RequestParam.new('countryCode', 'NL'),
+                Worldline::Connect::SDK::Communication::RequestParam.new('currencyCode', 'EUR')]
 
     expect(params.to_request_parameters).to include(expected)
   end

data/spec/lib/requestparams/find_params_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
-require 'ingenico/connect/sdk/merchant/products/find_products_params'
-require 'ingenico/connect/sdk/merchant/productgroups/find_productgroups_params'
+require 'worldline/connect/sdk/v1/merchant/products/find_products_params'
+require 'worldline/connect/sdk/v1/merchant/productgroups/find_productgroups_params'
 
-RequestParam ||= Ingenico::Connect::SDK::RequestParam
+RequestParam ||= Worldline::Connect::SDK::Communication::RequestParam
 
 shared_examples_for 'FindParams' do
 
@@ -42,8 +42,8 @@ shared_examples_for 'FindParams' do
   end
 end
 
-FindProductsParams ||= Ingenico::Connect::SDK::Merchant::Products::FindProductsParams
-FindProductgroupParams ||= Ingenico::Connect::SDK::Merchant::Productgroups::FindProductgroupsParams
+FindProductsParams ||= Worldline::Connect::SDK::V1::Merchant::Products::FindProductsParams
+FindProductgroupParams ||= Worldline::Connect::SDK::V1::Merchant::Productgroups::FindProductgroupsParams
 
 describe FindProductsParams do
   let(:params){FindProductsParams.new}

data/spec/lib/requestparams/get_params_spec.rb

@@ -1,9 +1,9 @@
 require 'rspec'
 require 'spec_helper'
-require 'ingenico/connect/sdk/merchant/products/get_product_params'
-require 'ingenico/connect/sdk/merchant/productgroups/get_productgroup_params'
+require 'worldline/connect/sdk/v1/merchant/products/get_product_params'
+require 'worldline/connect/sdk/v1/merchant/productgroups/get_productgroup_params'
 
-RequestParam ||= Ingenico::Connect::SDK::RequestParam
+RequestParam ||= Worldline::Connect::SDK::Communication::RequestParam
 
 shared_examples_for 'GetParams' do
 
@@ -43,8 +43,8 @@ shared_examples_for 'GetParams' do
   end
 end
 
-GetProductParams ||= Ingenico::Connect::SDK::Merchant::Products::GetProductParams
-GetProductgroupParams ||= Ingenico::Connect::SDK::Merchant::Productgroups::GetProductgroupParams
+GetProductParams ||= Worldline::Connect::SDK::V1::Merchant::Products::GetProductParams
+GetProductgroupParams ||= Worldline::Connect::SDK::V1::Merchant::Productgroups::GetProductgroupParams
 
 describe GetProductParams do
   let(:params){GetProductParams.new}

data/spec/lib/webhooks/webhooks_helper_spec.rb

@@ -1,7 +1,10 @@
 require 'spec_helper'
 
-include Ingenico::Connect::SDK
-describe Webhooks::WebhooksHelper do
+include Worldline::Connect::SDK
+
+DefaultMarshaller ||= Worldline::Connect::SDK::JSON::DefaultMarshaller
+
+describe V1::Webhooks::WebhooksHelper do
 
   # define constants for the testbench
   SIGNATURE_HEADER = "X-GCS-Signature"
@@ -10,8 +13,8 @@ describe Webhooks::WebhooksHelper do
   KEY_ID = "dummy-key-id"
   SECRET_KEY = "hello+world"
 
-  def create_helper(marshaller = DefaultImpl::DefaultMarshaller.INSTANCE)
-    Webhooks::WebhooksHelper.new(marshaller, Webhooks::InMemorySecretKeyStore.instance)
+  def create_helper(marshaller = DefaultMarshaller.instance)
+    V1::Webhooks::WebhooksHelper.new(marshaller, Webhooks::InMemorySecretKeyStore.instance)
   end
 
   def read_resource(resource_name)
@@ -36,7 +39,7 @@ describe Webhooks::WebhooksHelper do
 
     it 'should raise ApiVersionMismatchException when API version does not match' do
       # mock marshaller once to return an event with a wrong API version number
-      expect(DefaultImpl::DefaultMarshaller.INSTANCE).to receive(:unmarshal) do |body, klass|
+      expect(DefaultMarshaller.instance).to receive(:unmarshal) do |body, klass|
         event = klass.new_from_hash(JSON.load(body))
         event.api_version = 'v0' # wrong version
         event

data/spec/lib/webhooks/webhooks_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
-include Ingenico::Connect::SDK
+include Worldline::Connect::SDK
 
 describe Webhooks::Webhooks do
-  let(:webhooks_helper) { Webhooks::Webhooks.create_helper(Webhooks::InMemorySecretKeyStore.instance) }
+  let(:webhooks_helper) { Webhooks::Webhooks.v1.create_helper(Webhooks::InMemorySecretKeyStore.instance) }
 
   context 'construction' do
     it 'uses the default marshaller' do
-      expect(webhooks_helper.instance_variable_get(:@marshaller)).to eq(DefaultImpl::DefaultMarshaller.INSTANCE)
+      expect(webhooks_helper.instance_variable_get(:@marshaller)).to eq(Worldline::Connect::SDK::JSON::DefaultMarshaller.instance)
     end
 
     it 'uses the given key store' do

data/spec/spec_helper.rb

@@ -1,7 +1,7 @@
 require 'rspec'
 require 'webmock/rspec'
 
-require 'ingenico/connect/sdk'
+require 'worldline/connect/sdk'
 require 'comparable_extension'
 
 RSpec.configure do |config|
@@ -14,9 +14,9 @@ RSpec.configure do |config|
   # declaration of constants to use throughout the tests
   config.before(:suite) do
     PROPERTIES_URI = File.expand_path('../../spec/fixtures/resources/properties.yml', __FILE__)
-    API_KEY_ID = 'somekey'
+    API_KEY_ID = 'someKey'
     SECRET_API_KEY = 'someSecret'
-    CLIENT = Ingenico::Connect::SDK::Factory.create_client_from_file(PROPERTIES_URI, API_KEY_ID, SECRET_API_KEY)
+    CLIENT = Worldline::Connect::SDK::Factory.create_client_from_file(PROPERTIES_URI, API_KEY_ID, SECRET_API_KEY)
   end
 
   config.after(:suite) { CLIENT.close }