acquiring-sdk-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fbe14771bc49443b36f8ef127ab56e7c24db6b0f303a829032efa785891e52fb
+  data.tar.gz: cf3df20c97cb1d9add95fe64ded24ce955248ef32d69049a2fa98812d3a7199a
+SHA512:
+  metadata.gz: 3efbf4847c46be0f3ac265628581d1e880b2950b7b6793f3b6ae9100e4b830479be35f47674bda088447d55634e7dcbaf70a79d9524eb9f2736ff3297dbd8941
+  data.tar.gz: a94f4720710ebeb5e54db83f57c92e58096ccc72a3af197298a0558253096c0590b74e6f30569c8aa9e165cd2ec56e7d81678ed93725f2f4bc891734482fd2e8

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2024 Worldline Financial Services (Europe) SA
+
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,140 @@
+# Worldline Acquiring Ruby SDK
+
+## Introduction
+
+The Ruby SDK helps you to communicate with the Worldline Acquiring API. Its primary features are:
+
+* convenient Ruby library for the API calls and responses
+    * marshalls Ruby request objects to HTTP requests
+    * unmarshalls HTTP responses to Ruby response objects or Ruby exceptions
+* handling of all the details concerning authentication
+* handling of required metadata
+
+See the [Worldline Acquiring Documentation](https://docs.acquiring.worldline-solutions.com/Developer-Tools/sdk/ruby) for more information on how to use the SDK.
+
+## Structure of this repository
+
+This repository consists out of four main components:
+
+1. The source code of the SDK itself: `/lib/worldline/acquiring/sdk/`
+2. The source code of the SDK unit tests: `/spec/lib/`
+3. The source code of the SDK integration tests: `/spec/integration/`
+
+Note that the source code of the unit tests and integration tests can only be found on GitHub.
+
+## Requirements
+
+Ruby 2.3 or higher is required.
+As for JRuby, version 9.0.0.0 and higher are supported.
+In addition, the following packages are required:
+
+* [httpclient](https://github.com/nahi/httpclient) 2.8 or higher
+* [concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby) 1.0 or higher
+
+## Installation
+
+### Using RubyGems
+
+To install the SDK using `gem`, execute the following command:
+
+    gem install acquiring-sdk-ruby
+
+### Using a pre-built gem
+
+1. Download the latest version of the Ruby SDK from GitHub. Choose the `acquiring-sdk-ruby-x.y.z.gem` file from the [releases](https://github.com/Worldline-Acquiring/acquiring-sdk-ruby/releases) page, where `x.y.z` is the version number.
+2. Navigate into the folder where the gem file is downloaded to, and execute the following command:
+
+    ```
+    gem install acquiring-sdk-ruby-x.y.z.gem
+    ```
+3. Feel free to delete the gem file at this point, it is no longer required.
+
+### From source
+
+1. Download the latest version of the Ruby SDK from GitHub. Choose the `acquiring-sdk-ruby-x.y.z.zip` file from the [releases](https://github.com/Worldline-Acquiring/acquiring-sdk-ruby/releases) page, where `x.y.z` is the version number.
+2. Unzip the file, navigate into the folder where the file is unzipped to, and execute the following commands:
+
+    ```
+    gem build acquiring-sdk-ruby.gemspec
+    gem install acquiring-sdk-ruby-x.y.z.gem
+    ```
+3. Feel free to delete the unzipped archive, the zip file and the gem file at this point, they are no longer required.
+
+## Uninstalling
+
+After the Ruby SDK has been installed, it can be uninstalled using the
+following command:
+
+    gem uninstall acquiring-sdk-ruby
+
+The required packages can be uninstalled in the same way.
+
+## Usage
+
+After the Ruby SDK has been installed, it can be required in Ruby program as follows:
+
+    require 'worldline/acquiring/sdk'
+
+## Running tests
+
+There are two types of tests: unit tests and integration tests. The unit tests will work out-of-the-box; for the integration tests some configuration is required.
+First, some environment variables need to be set:
+
+* `acquiring_api_oauth2_clientId` for the OAuth2 client id to use.
+* `acquiring_api_oauth2_clientsecret` for the OAuth2 client secret to use.
+* `acquiring_api_merchantId` for your merchant ID.
+
+In addition, to run the proxy integration tests, the proxy URI, username and password should be set in the `spec/fixtures/resources/properties.proxy.yml` file.
+
+In order to run the unit and integration tests, some additional dependencies are required:
+
+* [rake](https://ruby.github.io/rake/) 12.3.3 or higher
+* [rspec](https://github.com/rspec/rspec) 3.5 or higher
+* [webmock](https://github.com/bblimke/webmock) 2.1 or higher
+* [sinatra](https://github.com/sinatra/sinatra) 2.1 or higher
+* [webrick](https://github.com/ruby/webrick) 1.7 or higher
+
+They can be installed using the following command:
+
+    gem install rake rspec webmock sinatra
+
+*Note: if rake is already installed as part of the Ruby installation, this will cause a conflict error. This can safely be ignored.*
+
+The following commands can now be executed from the root directory of the SDK folder (/) to execute the tests:
+
+* Unit tests:
+
+    ```
+    rake unit
+    ```
+
+* Integration tests:
+
+    ```
+    rake integration
+    ```
+
+* Both unit and integration tests:
+
+    ```
+    rake spec
+    ```
+
+## Generating documentation
+
+Documentation can be generated with YARD. YARD can be installed as a gem. The gems required to generate documentation are:
+
+* [rake](https://ruby.github.io/rake/) 12.3.3 or higher
+* [yard](https://github.com/lsegal/yard) 0.9.5 or higher
+
+They can be installed using the following command:
+
+    gem install rake yard
+
+*Note: if rake is already installed as part of the Ruby installation, this will cause a conflict error. This can safely be ignored.*
+
+Once YARD and rake are installed, documentation can be generated with the following command (ran from the root folder):
+
+    rake yard
+
+Documentation will be generated in the `/doc` folder. The file `/doc/index.html` is the main documentation file.

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec) do |t|  # supports automated testing using the command *rake* *spec*
+    t.rspec_opts = '--color --format documentation'
+  end
+
+  RSpec::Core::RakeTask.new(:unit) do |t|  # supports automated testing using unit tests using the command *rake* *unit*
+    t.rspec_opts = '--color --format documentation'
+    t.exclude_pattern = 'spec/integration/**'
+  end
+
+  RSpec::Core::RakeTask.new(:integration) do |t|  # supports automated testing of integration using the command *rake* *integration*
+    t.rspec_opts = '--color --format documentation'
+    t.pattern = 'spec/integration/**_spec.rb'
+  end
+
+  task :default => :spec
+rescue LoadError
+  puts '[*] error -- development dependency is not installed'
+end
+
+begin
+  require 'yard'
+
+  YARD::Rake::YardocTask.new(:yard) do |t|  # supports generating documentation using the command *rake* *yard*
+      # t.files   = ['lib/**/*.rb', OTHER_PATHS]   # optional
+      t.options = ['--no-private']
+  end
+
+  task :doc => :yard  # alternative alias to generate documentation
+rescue LoadError
+  puts '[*] error -- development dependency is not installed'
+end

data/acquiring-sdk-ruby.gemspec

@@ -0,0 +1,30 @@
+Gem::Specification.new do |spec|
+  spec.name           = 'acquiring-sdk-ruby'
+  spec.version        = '0.1.0'
+  spec.authors        = ['Worldline Acquiring']
+  spec.email          = ['github.acquiring@worldline.com']
+  spec.summary        = %q{SDK to communicate with the Worldline Acquiring platform using the Worldline Acquiring API}
+  spec.description    = %q{SDK to communicate with the Worldline Acquiring platform using the Worldline Acquiring API}
+  spec.homepage       = %q{https://github.com/Worldline-Acquiring/acquiring-sdk-ruby}
+  spec.license        = 'MIT'
+
+  # exclude hidden files like .gitignore
+  spec.files          = Dir['lib/**/*'] + Dir['spec/**/*'] +
+                        ['acquiring-sdk-ruby.gemspec', 'Gemfile', 'LICENSE.txt', 'Rakefile', 'README.md']
+  spec.executables    = spec.files.grep(%r{^bin\/}) { |f| File.basename(f) }
+  spec.test_files     = spec.files.grep(%r{^(test|spec|features)\/})
+  spec.require_paths  = ['lib']
+
+  spec.required_ruby_version = '>= 2.0'
+
+  spec.add_dependency 'httpclient', '~> 2.8'
+  spec.add_dependency 'concurrent-ruby', '~>1.0'
+
+  spec.add_development_dependency 'yard', '~> 0.9'
+  spec.add_development_dependency 'rspec', '~> 3.5'
+  spec.add_development_dependency 'webmock', '~> 2.1'
+  spec.add_development_dependency 'sinatra', '~> 2.1'
+  spec.add_development_dependency 'webrick', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 12.3', '>= 12.3.3'
+  # spec.metadata['yard.run'] = 'yri'  # compiles yard doc on install
+end

data/lib/worldline/acquiring/sdk/api_resource.rb

@@ -0,0 +1,53 @@
+module Worldline
+  module Acquiring
+    module SDK
+      # Base class of all Worldline Acquiring platform API resources.
+      # Provides shared functionality to facilitate communication with the Worldline Acquiring platform.
+      #
+      # @attr_reader [Worldline::Acquiring::SDK::Communicator] communicator Communicator instance that provides communication with the Worldline Acquiring platform.
+      class ApiResource
+
+        # Creates a new ApiResource.
+        #
+        # @param parent           [Worldline::Acquiring::SDK::ApiResource] parent resource instance.
+        # @param communicator     [Worldline::Acquiring::SDK::Communicator] Communicator instance.
+        # @param path_context     [Hash] hash that contains substitutions for generic locations in the URL path.
+        #                         This hash will be used to instantiate a concrete URL used to access specific resources.
+        def initialize(parent: nil, communicator: nil, path_context: nil)
+          raise ArgumentError.new('parent and/or communicator is required') if parent.nil? and communicator.nil?
+          @parent = parent
+          @communicator = communicator.nil? ? parent.communicator : communicator
+          @path_context = path_context
+        end
+
+        attr_reader :communicator
+
+        protected
+
+        def instantiate_uri(uri, path_context = nil)
+          if path_context
+            uri = replace_all(uri, path_context)
+            instantiate_uri(uri)
+          else
+            uri = replace_all(uri, @path_context)
+            unless @parent.nil?
+              uri = @parent.instantiate_uri(uri)
+            end
+            uri
+          end
+        end
+
+        private
+
+        def replace_all(uri, path_context)
+          if path_context
+            path_context.each do |key, value|
+              uri = uri.gsub('{' + key + '}', value)
+            end
+          end
+          uri
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/authentication/authenticator.rb

@@ -0,0 +1,21 @@
+module Worldline
+  module Acquiring
+    module SDK
+      module Authentication
+        # Abstract class that is responsible for authenticating requests sent to the Worldline Acquiring platform.
+        class Authenticator
+
+          # Returns a value that can be used for the "Authorization" header.
+          #
+          # @param http_method     [String] 'GET', 'PUT', 'POST' or 'DELETE' indicating which HTTP method will be used with the request
+          # @param resource_uri    [URI::HTTP] URI object that includes #path and #query of the URL that will be used, #query may be *nil*
+          # @param request_headers [Array<Worldline::Acquiring::SDK::Communication::RequestHeader>] all headers used by the request
+          # @return [String] the "Authorization" header value
+          def get_authorization(http_method, resource_uri, request_headers)
+            raise NotImplementedError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/authentication/authorization_type.rb

@@ -0,0 +1,17 @@
+module Worldline
+  module Acquiring
+    module SDK
+      module Authentication
+        # Contains all authentication schemes supported by the Worldline Acquiring platform.
+        class AuthorizationType
+          OAUTH2 = "OAuth2".freeze
+
+          # @return [String] the authorization string that belongs to the parameter _authorization_, or _nil_ if not found.
+          def self.get_authorization(authorization)
+            authorization if authorization == 'OAuth2'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/authentication/oauth2_authenticator.rb

@@ -0,0 +1,142 @@
+require 'concurrent'
+require 'worldline/acquiring/sdk/authentication/authenticator'
+require 'worldline/acquiring/sdk/authentication/oauth2_exception'
+require 'worldline/acquiring/sdk/communication/default_connection'
+require 'worldline/acquiring/sdk/communication/request_header'
+
+module Worldline
+  module Acquiring
+    module SDK
+      module Authentication
+        # Authenticates requests made to the Worldline Acquiring platform using OAuth2.
+        class OAuth2Authenticator < Authenticator
+
+          private
+
+          class TokenType
+
+            def initialize(path, scopes)
+              @path = path
+              @scopes = scopes.join(' ')
+            end
+
+            attr_reader :path
+            attr_reader :scopes
+          end
+
+          class AccessToken
+
+            def initialize(token, expiration)
+              @token = token
+              @expiration = expiration
+            end
+
+            attr_reader :token
+            attr_reader :expiration
+          end
+
+          # Only a limited amount of scopes may be sent in one request.
+          # While at the moment all scopes fit in one request, keep this code so we can easily add more token types if necessary.
+          # The empty path will ensure that all paths will match, as each full path ends with an empty string.
+          TOKEN_TYPES = [
+            TokenType.new('', [
+              'processing_payment', 'processing_refund', 'processing_credittransfer', 'processing_accountverification',
+              'processing_operation_reverse', 'processing_dcc_rate', 'services_ping'
+            ]),
+          ]
+
+          public
+
+          # Constructs a new OAuth2Authenticator instance using the provided CommunicatorConfiguration.
+          #
+          # @param communicator_configuration [Worldline::Acquiring::SDK::CommunicatorConfiguration] The configuration object
+          #                                   containing the OAuth2 client id, client secret and token URI,
+          #                                   connection timeout, and socket timeout. None of these can be _nil_ or empty,
+          #                                   and the timeout values must be positive.
+          def initialize(communicator_configuration)
+            raise ArgumentError unless communicator_configuration.oauth2_client_id and not communicator_configuration.oauth2_client_id.strip.empty?
+            raise ArgumentError unless communicator_configuration.oauth2_client_secret and not communicator_configuration.oauth2_client_secret.strip.empty?
+            raise ArgumentError unless communicator_configuration.oauth2_token_uri and not communicator_configuration.oauth2_token_uri.strip.empty?
+            raise ArgumentError unless communicator_configuration.connect_timeout > 0
+            raise ArgumentError unless communicator_configuration.socket_timeout > 0
+
+            @access_tokens = Concurrent::Map.new
+            @client_id = communicator_configuration.oauth2_client_id
+            @client_secret = communicator_configuration.oauth2_client_secret
+            @token_uri = communicator_configuration.oauth2_token_uri
+            @connect_timeout = communicator_configuration.connect_timeout
+            @socket_timeout = communicator_configuration.socket_timeout
+            @proxy_configuration = communicator_configuration.proxy_configuration
+          end
+
+          # @param http_method     [String, nil] 'GET', 'PUT', 'POST' or 'DELETE' indicating which HTTP method will be used with the request
+          # @param resource_uri    [URI::HTTP, nil] URI object that includes #path and #query of the URL that will be used, #query may be *nil*
+          # @param request_headers [Array<Worldline::Acquiring::SDK::Communication::RequestHeader>, nil] all headers used by the request
+          def get_authorization(http_method, resource_uri, request_headers)
+            token_type = get_token_type(resource_uri&.path)
+            access_token = @access_tokens.compute(token_type.path) { |existing_token| get_valid_access_token(existing_token, token_type) }
+            "Bearer #{access_token.token}"
+          end
+
+          private
+
+          def get_token_type(full_path)
+            TOKEN_TYPES.each do |token_type|
+              if full_path&.end_with? token_type.path || full_path&.include?("#{token_type.path}/")
+                return token_type
+              end
+            end
+            raise ArgumentError.new("scope could not be found for path '#{full_path}'")
+          end
+
+          def get_valid_access_token(existing_token, token_type)
+            if is_token_invalid(existing_token)
+              return get_access_token(token_type)
+            end
+            existing_token
+          end
+
+          def is_token_invalid(access_token)
+            not access_token or access_token.expiration < Time.now
+          end
+
+          def get_access_token(token_type)
+            request_headers = [RequestHeader.new('Content-Type', 'application/x-www-form-urlencoded')]
+            request_body = "grant_type=client_credentials&client_id=#{@client_id}&client_secret=#{@client_secret}&scope=#{token_type.scopes}"
+
+            start_time = Time.now
+
+            new_connection do |connection|
+              response_status_code, access_token_response = nil
+              connection.post(@token_uri, request_headers, request_body) do |status_code, _, content|
+                response_status_code = status_code
+                response_body = content.read.force_encoding('UTF-8')
+                access_token_response = ::JSON.load(response_body)
+              end
+
+              if response_status_code != 200
+                error = access_token_response['error']
+                error_description = access_token_response['error_description']
+                raise OAuth2Exception.new("There was an error while retrieving the OAuth2 access token: #{error} - #{error_description}")
+              end
+
+              token = access_token_response['access_token']
+              expiration = start_time + access_token_response['expires_in']
+              AccessToken.new(token, expiration)
+            end
+          end
+
+          def new_connection
+            connection = Worldline::Acquiring::SDK::Communication::DefaultConnection.new({ connect_timeout: @connect_timeout,
+                                                                                           socket_timeout: @socket_timeout,
+                                                                                           max_connections: 1,
+                                                                                           proxy_configuration: @proxy_configuration })
+            yield connection
+          ensure
+            connection.close
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/authentication/oauth2_exception.rb

@@ -0,0 +1,15 @@
+module Worldline
+  module Acquiring
+    module SDK
+      module Authentication
+        # Raised when an exception regarding the authorization with the Worldline OAuth2 Authorization Server occurs.
+        class OAuth2Exception < RuntimeError
+
+          def initialize(message)
+            super(message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/authentication.rb

@@ -0,0 +1 @@
+Dir[File.join(__dir__, 'authentication', '*.rb')].each { |f| require f }

data/lib/worldline/acquiring/sdk/call_context.rb

@@ -0,0 +1,9 @@
+module Worldline
+  module Acquiring
+    module SDK
+      # A CallContext is used to identify requests.
+      class CallContext
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/client.rb

@@ -0,0 +1,69 @@
+#
+# This file was automatically generated.
+#
+require 'worldline/acquiring/sdk/api_resource'
+require 'worldline/acquiring/sdk/logging/logging_capable'
+require 'worldline/acquiring/sdk/logging/obfuscation/obfuscation_capable'
+require 'worldline/acquiring/sdk/v1/v1_client'
+
+module Worldline
+  module Acquiring
+    module SDK
+      # Worldline Acquiring platform client.
+      #
+      # Thread safe.
+      class Client < ApiResource
+        include Logging::LoggingCapable
+        include Logging::Obfuscation::ObfuscationCapable
+
+        # @param communicator [Worldline::Acquiring::SDK::Communicator]
+        def initialize(communicator)
+          super(communicator: communicator)
+        end
+
+        # Utility method that delegates the call to this client's communicator.
+        def close_idle_connections(idle_time)
+          @communicator.close_idle_connections(idle_time)
+        end
+
+        # Utility method that delegates the call to this client's communicator.
+        def close_expired_connections
+          @communicator.close_expired_connections
+        end
+
+        # Sets the current body obfuscator to use.
+        # @param body_obfuscator [Worldline::Acquiring::SDK::Logging::Obfuscation::BodyObfuscator]
+        def set_body_obfuscator(body_obfuscator)
+          @communicator.set_body_obfuscator(body_obfuscator)
+        end
+
+        # Sets the current header obfuscator to use.
+        # @param header_obfuscator [Worldline::Acquiring::SDK::Logging::Obfuscation::HeaderObfuscator]
+        def set_header_obfuscator(header_obfuscator)
+          @communicator.set_header_obfuscator(header_obfuscator)
+        end
+
+        # Turns on logging using the given communicator logger.
+        # @param communicator_logger [Worldline::Acquiring::SDK::Logging::CommunicatorLogger]
+        def enable_logging(communicator_logger)
+          @communicator.enable_logging(communicator_logger)
+        end
+
+        # Turns off logging.
+        def disable_logging
+          @communicator.disable_logging
+        end
+
+        # Releases any system resources associated with this object.
+        def close
+          @communicator.close
+        end
+
+        # @return [Worldline::Acquiring::SDK::V1::V1Client]
+        def v1
+          Worldline::Acquiring::SDK::V1::V1Client.new(self, nil)
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/communication/communication_exception.rb

@@ -0,0 +1,21 @@
+module Worldline
+  module Acquiring
+    module SDK
+      module Communication
+        # This exception is used when an error occurs during network communication with the Worldline Acquiring platform.
+        # A common cause is a timeout while connecting or when receiving or sending data.
+        #
+        # @attr [Exception] cause The error that is the cause of this error.
+        class CommunicationException < RuntimeError
+
+          def initialize(cause)
+            super()
+            @cause = cause
+          end
+
+          attr_accessor :cause
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/communication/connection.rb

@@ -0,0 +1,50 @@
+require 'worldline/acquiring/sdk/logging/logging_capable'
+require 'worldline/acquiring/sdk/logging/obfuscation/obfuscation_capable'
+
+module Worldline
+  module Acquiring
+    module SDK
+      module Communication
+        # Class used to communicate using the HTTP (or HTTPS) protocol.
+        # Performs GET, DELETE, POST and PUT requests given a target uri and request headers.
+        # @see Worldline::Acquiring::SDK::Communication::DefaultConnection
+        class Connection
+          include Worldline::Acquiring::SDK::Logging::LoggingCapable
+          include Worldline::Acquiring::SDK::Logging::Obfuscation::ObfuscationCapable
+
+          # Performs a GET request to _uri_ using _request_headers_,
+          # and yields the response as the status code, headers and body.
+          #
+          # @yield (Integer, Array<Worldline::Acquiring::SDK::Communication::ResponseHeader>, IO) The status code, headers and body of the response.
+          def get(uri, request_headers)
+            raise NotImplementedError
+          end
+
+          # Performs a DELETE request to _uri_ using _request_headers_,
+          # and yields the response as the status code, headers and body.
+          #
+          # @yield (Integer, Array<Worldline::Acquiring::SDK::Communication::ResponseHeader>, IO) The status code, headers and body of the response.
+          def delete(uri, request_headers)
+            raise NotImplementedError
+          end
+
+          # Performs a POST request to _uri_ using _request_headers_ and _body_,
+          # and yields the response as the status code, headers and body.
+          #
+          # @yield (Integer, Array<Worldline::Acquiring::SDK::Communication::ResponseHeader>, IO) The status code, headers and body of the response.
+          def post(uri, request_headers, body)
+            raise NotImplementedError
+          end
+
+          # Performs a PUT request to _uri_ using _request_headers_ and _body_,
+          # and yields the response as the status code, headers and body.
+          #
+          # @yield (Integer, Array<Worldline::Acquiring::SDK::Communication::ResponseHeader>, IO) The status code, headers and body of the response.
+          def put(uri, request_headers, body)
+            raise NotImplementedError
+          end
+        end
+      end
+    end
+  end
+end