mangopay4-ruby-sdk 3.44.0

data/lib/mangopay.rb

@@ -0,0 +1,456 @@
+require 'net/http'
+require 'cgi/util'
+require 'digest/md5'
+require 'multi_json'
+require 'benchmark'
+require 'logger'
+require 'time'
+require 'securerandom'
+
+# helpers
+require 'mangopay/version'
+require 'mangopay/errors'
+
+
+module MangoPay
+
+  autoload :HTTPCalls, 'mangopay/http_calls'
+  autoload :Resource, 'mangopay/resource'
+  autoload :Client, 'mangopay/client'
+  autoload :User, 'mangopay/user'
+  autoload :NaturalUser, 'mangopay/natural_user'
+  autoload :NaturalUserSca, 'mangopay/natural_user_sca'
+  autoload :LegalUserSca, 'mangopay/legal_user_sca'
+  autoload :LegalUser, 'mangopay/legal_user'
+  autoload :PayIn, 'mangopay/pay_in'
+  autoload :PayOut, 'mangopay/pay_out'
+  autoload :Transfer, 'mangopay/transfer'
+  autoload :Transaction, 'mangopay/transaction'
+  autoload :Wallet, 'mangopay/wallet'
+  autoload :BankAccount, 'mangopay/bank_account'
+  autoload :CardRegistration, 'mangopay/card_registration'
+  autoload :PreAuthorization, 'mangopay/pre_authorization'
+  autoload :Card, 'mangopay/card'
+  autoload :Event, 'mangopay/event'
+  autoload :KycDocument, 'mangopay/kyc_document'
+  autoload :Hook, 'mangopay/hook'
+  autoload :Refund, 'mangopay/refund'
+  autoload :Dispute, 'mangopay/dispute'
+  autoload :Mandate, 'mangopay/mandate'
+  autoload :Report, 'mangopay/report'
+  autoload :ReportV2, 'mangopay/report_v2'
+  autoload :JSON, 'mangopay/json'
+  autoload :AuthorizationToken, 'mangopay/authorization_token'
+  autoload :FilterParameters, 'mangopay/filter_parameters'
+  autoload :BankingAliases, 'mangopay/bankingaliases'
+  autoload :BankingAliasesIBAN, 'mangopay/bankingaliases_iban'
+  autoload :UboDeclaration, 'mangopay/ubo_declaration'
+  autoload :Ubo, 'mangopay/ubo'
+  autoload :Regulatory, 'mangopay/regulatory'
+  autoload :Deposit, 'mangopay/deposit'
+  autoload :Conversion, 'mangopay/conversion'
+  autoload :PaymentMethodMetadata, 'mangopay/payment_method_metadata'
+  autoload :VirtualAccount, 'mangopay/virtual_account'
+  autoload :IdentityVerification, 'mangopay/identity_verification'
+  autoload :Recipient, 'mangopay/recipient'
+  autoload :Settlement, 'mangopay/settlement'
+  autoload :Acquiring, 'mangopay/acquiring'
+
+  # temporary
+  autoload :Temp, 'mangopay/temp'
+
+  @configurations = {}
+
+  class Configuration
+    attr_accessor :preproduction, :root_url,
+                  :client_id, :client_apiKey,
+                  :temp_dir, :log_file, :log_trace_headers, :http_timeout,
+                  :http_max_retries, :http_open_timeout,
+                  :logger, :use_ssl, :uk_header_flag,
+                  :after_request_proc
+
+    def apply_configuration
+      MangoPay.configure do |config|
+        config.preproduction = @preproduction
+        config.client_id = @client_id
+        config.client_apiKey = @client_apiKey
+        config.log_file = @log_file
+        config.log_trace_headers = @log_trace_headers
+        config.http_timeout = @http_timeout
+        config.http_max_retries = @http_max_retries
+        config.http_open_timeout = @http_open_timeout
+        config.use_ssl = @use_ssl
+        config.logger = @logger
+        config.uk_header_flag = @uk_header_flag
+        config.after_request_proc = @after_request_proc
+      end
+    end
+
+    def preproduction
+      @preproduction || false
+    end
+
+    def root_url
+      @root_url || (@preproduction == true ? "https://api.sandbox.mangopay.com" : "https://api.mangopay.com")
+    end
+
+    def http_timeout
+      @http_timeout || 30
+    end
+
+    def http_max_retries
+      @http_max_retries || 1
+    end
+
+    def http_open_timeout
+      @http_open_timeout || 30
+    end
+
+    def use_ssl?
+      return true unless preproduction == true
+      return true unless defined?(@use_ssl)
+      return false if @use_ssl == false
+
+      true
+    end
+
+    def log_trace_headers
+      @log_trace_headers || false
+    end
+
+    def uk_header_flag
+      @uk_header_flag || false
+    end
+  end
+
+  class << self
+    def version_code
+      "v2.01"
+    end
+
+    def version_code_v3
+      "V3.0"
+    end
+
+    def api_path
+      "/#{version_code}/#{MangoPay.configuration.client_id}"
+    end
+
+    def api_path_no_client
+      "/#{version_code}"
+    end
+
+    def api_path_v3
+      "/#{version_code_v3}/#{MangoPay.configuration.client_id}"
+    end
+
+    def api_uri(url='')
+      URI(configuration.root_url + url)
+    end
+
+    def configuration=(value)
+      Thread.current[:mangopay_configuration] = value
+      @last_configuration_set = value
+    end
+
+    def configuration
+      config = Thread.current[:mangopay_configuration]
+
+      config                                                ||
+      ( @last_configuration_set &&
+        (self.configuration = @last_configuration_set.dup)) ||
+      (self.configuration = MangoPay::Configuration.new)
+    end
+
+    def configure
+      config = self.configuration
+      yield config
+      self.configuration = config
+    end
+
+    def with_configuration(config)
+      original_config = MangoPay.configuration
+      MangoPay.configuration = config
+      yield
+    ensure
+      MangoPay.configuration = original_config
+    end
+
+    def ratelimit
+      @ratelimit
+    end
+
+    def ratelimit=(obj)
+      @ratelimit = obj
+    end
+
+    # Add MangoPay.Configuration to the list of configs
+    def add_config(name, config)
+      @configurations[name] = config
+    end
+
+    # Fetch a MangoPay configuration from the list of configs. Throw error if not found
+    def get_config(name)
+      config = @configurations[name]
+      raise "Could not find any configuration with name '#{name}'" unless config
+      config
+    end
+
+    def remove_config(name)
+      raise "Could not find any configuration with name '#{name}'" unless @configurations[name]
+      @configurations[name] = nil
+    end
+
+    #
+    # - +method+: HTTP method; lowercase symbol, e.g. :get, :post etc.
+    # - +url+: the part after Configuration#root_url
+    # - +params+: hash; entity data for creation, update etc.; will dump it by JSON and assign to Net::HTTPRequest#body
+    # - +filters+: hash; pagination params etc.; will encode it by URI and assign to URI#query
+    # - +headers_or_idempotency_key+: hash of headers; or replaced by request_headers if nil; or added to request_headers as idempotency key otherwise (see https://docs.mangopay.com/api-references/idempotency-support/)
+    # - +before_request_proc+: optional proc; will call it passing the Net::HTTPRequest instance just before Net::HTTPRequest#request
+    #
+    # Raises MangoPay::ResponseError if response code != 200.
+    #
+    def request(method, url, params={}, filters={}, headers_or_idempotency_key = nil, before_request_proc = nil)
+      uri = api_uri(url)
+      uri.query = URI.encode_www_form(filters) unless filters.empty?
+
+      if headers_or_idempotency_key.is_a?(Hash)
+        headers = headers_or_idempotency_key
+      else
+        headers = request_headers
+        headers['Idempotency-Key'] = headers_or_idempotency_key if headers_or_idempotency_key != nil
+      end
+
+      if configuration.uk_header_flag
+        headers['x-tenant-id'] = 'uk'
+      end
+
+      res = Net::HTTP.start(uri.host, uri.port, :use_ssl => configuration.use_ssl?, :read_timeout => configuration.http_timeout,
+                            :max_retries => configuration.http_max_retries,
+                            :open_timeout => configuration.http_open_timeout, ssl_version: :TLSv1_2) do |http|
+        req = Net::HTTP::const_get(method.capitalize).new(uri.request_uri, headers)
+        req.body = JSON.dump(params)
+        before_request_proc.call(req) if before_request_proc
+        do_request(http, req, uri)
+      end
+
+      raise MangoPay::ResponseError.new(uri, '408', {'Message' => 'Request Timeout'}) if res.nil?
+
+      # decode json data
+      begin
+        data = res.body.to_s.empty? ? {} : JSON.load(res.body.to_s)
+      rescue MultiJson::ParseError
+        details = {}
+        details['Message'] = res.body
+        raise MangoPay::ResponseError.new(uri, res.code, details)
+      end
+
+      unless res.is_a?(Net::HTTPOK) or res.is_a?(Net::HTTPCreated) or res.is_a?(Net::HTTPNoContent)
+        if res.is_a?(Net::HTTPUnauthorized) and res['www-authenticate'] != nil
+          redirect_url = res['www-authenticate'][/RedirectUrl=(.+)/, 1]
+          data['RedirectUrl'] = redirect_url
+          data['message'] = 'SCA required to perform this action.'
+          raise MangoPay::ResponseError.new(uri, res.code, data)
+        end
+        raise MangoPay::ResponseError.new(uri, res.code, data)
+      end
+
+      # copy pagination info if any
+      ['x-number-of-pages', 'x-number-of-items'].each { |k|
+        filters[k.gsub('x-number-of-', 'total_')] = res[k].to_i if res[k]
+      }
+
+      if res['x-ratelimit']
+        self.ratelimit = {
+          limit: res['x-ratelimit'].split(", "),
+          remaining: res['x-ratelimit-remaining'].split(", "),
+          reset: res['x-ratelimit-reset'].split(", ")
+        }
+      end
+
+      configuration.after_request_proc&.call(data)
+
+      data
+    end
+
+    def request_multipart(method, url, file, file_name, idempotency_key = nil)
+      uri = api_uri(url)
+
+      # Set headers
+      headers = request_headers
+      headers['Idempotency-Key'] = idempotency_key if idempotency_key
+      headers['x-tenant-id'] = 'uk' if configuration.uk_header_flag
+
+      boundary = "#{SecureRandom.hex}"
+      headers['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
+
+      multipart_body = []
+      multipart_body << "--#{boundary}"
+      multipart_body << "Content-Disposition: form-data; name=\"file\"; filename=\"#{file_name}\""
+      multipart_body << ""
+      multipart_body << file
+      multipart_body << "--#{boundary}--"
+      multipart_body << ""
+
+      # Join string parts and ensure binary content is preserved
+      body = multipart_body.map { |part| part.is_a?(String) ? part.force_encoding("ASCII-8BIT") : part }.join("\r\n")
+
+      res = Net::HTTP.start(uri.host, uri.port,
+                            use_ssl: configuration.use_ssl?,
+                            read_timeout: configuration.http_timeout,
+                            open_timeout: configuration.http_open_timeout,
+                            max_retries: configuration.http_max_retries,
+                            ssl_version: :TLSv1_2) do |http|
+        req_class = Net::HTTP.const_get(method.capitalize)
+        req = req_class.new(uri.request_uri, headers)
+        req.body = body
+        do_request(http, req, uri)
+      end
+
+      raise MangoPay::ResponseError.new(uri, '408', { 'Message' => 'Request Timeout' }) if res.nil?
+
+      begin
+        data = res.body.to_s.empty? ? {} : JSON.load(res.body.to_s)
+      rescue MultiJson::ParseError
+        raise MangoPay::ResponseError.new(uri, res.code, { 'Message' => res.body })
+      end
+
+      unless res.is_a?(Net::HTTPOK) || res.is_a?(Net::HTTPCreated) || res.is_a?(Net::HTTPNoContent)
+        if res.is_a?(Net::HTTPUnauthorized) && res['www-authenticate']
+          redirect_url = res['www-authenticate'][/RedirectUrl=(.+)/, 1]
+          data['RedirectUrl'] = redirect_url
+          data['message'] = 'SCA required to perform this action.'
+        end
+        raise MangoPay::ResponseError.new(uri, res.code, data)
+      end
+
+      if res['x-ratelimit']
+        self.ratelimit = {
+          limit: res['x-ratelimit'].split(", "),
+          remaining: res['x-ratelimit-remaining'].split(", "),
+          reset: res['x-ratelimit-reset'].split(", ")
+        }
+      end
+
+      configuration.after_request_proc&.call(data)
+
+      data
+    end
+
+    # Retrieve a previous response by idempotency_key
+    # See https://docs.mangopay.com/api-references/idempotency-support/
+    def fetch_response(idempotency_key)
+      url = "#{api_path}/responses/#{idempotency_key}"
+      request(:get, url)
+    end
+
+    private
+
+    def user_agent
+      {
+          bindings_version: VERSION,
+          lang: 'ruby',
+          lang_version: "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
+          platform: RUBY_PLATFORM,
+          uname: get_uname
+      }
+    end
+
+    def get_uname
+      `uname -a 2>/dev/null`.strip if RUBY_PLATFORM =~ /linux|darwin/i
+    rescue Errno::ENOMEM
+      'uname lookup failed'
+    end
+
+    def request_headers
+      auth_token = AuthorizationToken::Manager.get_token
+      headers = {
+          'User-Agent' => "Mangopay-SDK/#{VERSION} (Ruby/#{RUBY_VERSION})",
+          'Authorization' => "#{auth_token['token_type']} #{auth_token['access_token']}",
+          'Content-Type' => 'application/json'
+      }
+      if configuration.log_trace_headers
+        headers.update('x_mangopay_trace-id' => SecureRandom.uuid)
+      end
+      begin
+        headers.update('x_mangopay_client_user_agent' => JSON.dump(user_agent))
+      rescue => e
+        headers.update('x_mangopay_client_raw_user_agent' => user_agent.inspect, error: "#{e} (#{e.class})")
+      end
+    end
+
+    def do_request(http, req, uri)
+      if logs_required?
+        do_request_with_log(http, req, uri)
+      else
+        do_request_without_log(http, req)
+      end
+    end
+
+    def do_request_with_log(http, req, uri)
+      res, time = nil, nil
+      params = FilterParameters.request(req.body)
+      if configuration.log_trace_headers
+        trace_headers = JSON.dump({ 'Idempotency-Key' => req['Idempotency-Key'] , 'x_mangopay_trace-id' =>  req['x_mangopay_trace-id'] })
+        line = "[#{Time.now.iso8601}] #{req.method.upcase} \"#{uri.to_s}\" #{params} #{trace_headers}"
+      else
+        line = "[#{Time.now.iso8601}] #{req.method.upcase} \"#{uri.to_s}\" #{params}"
+      end
+      begin
+        time = Benchmark.realtime {
+          begin
+            res = do_request_without_log(http, req)
+          rescue Net::ReadTimeout
+            res = nil
+          end
+        }
+        res
+      ensure
+        line = "#{log_severity(res)} #{line}"
+        if time.nil?
+          time_log = "[Unknown ms]"
+        else
+          time_log = "[#{(time * 1000).round(1)}ms]"
+        end
+        if res.nil?
+          params = ''
+          line += "\n  #{time_log} 408 Request Timeout #{params}\n"
+        else
+          params = FilterParameters.response(res.body)
+          line += "\n  #{time_log} #{res.code} #{params}\n"
+        end
+        logger.info { line }
+      end
+    end
+
+    def do_request_without_log(http, req)
+      http.request(req)
+    end
+
+    def log_severity(res)
+      errors = [Net::HTTPClientError, Net::HTTPServerError, Net::HTTPUnknownResponse]
+      errors.any? { |klass| res.is_a?(klass) } ? 'E' : 'I'
+    end
+
+    def logger
+      raise NotImplementedError unless logs_required?
+      return @logger if @logger
+
+      if !configuration.logger.nil?
+        @logger = configuration.logger
+      elsif !configuration.log_file.nil?
+        @logger = Logger.new(configuration.log_file)
+        @logger.formatter = proc do |_, _, _, msg|
+          "#{msg}\n"
+        end
+      end
+
+      @logger
+    end
+
+    def logs_required?
+      !configuration.log_file.nil? || !configuration.logger.nil?
+    end
+  end
+end

data/mangopay.gemspec

@@ -0,0 +1,30 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'mangopay/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'mangopay4-ruby-sdk'
+  s.version     = MangoPay::VERSION
+  s.summary     = "Ruby bindings for the version 2 of the MANGOPAY API"
+  s.description = <<-EOF
+  The mangopay Gem makes interacting with MANGOPAY Services much easier.
+  For any questions regarding the use of MANGOPAY's Services feel free to contact us at http://www.mangopay.com/get-started-2/
+  You can find more documentation about MANGOPAY Services at http://docs.mangopay.com/
+  EOF
+  s.authors     = ['Geoffroy Lorieux', 'Sergiusz Woznicki']
+  s.email       = 'support@mangopay.com'
+  s.homepage    = 'http://docs.mangopay.com/'
+  s.license     = 'MIT'
+
+  s.required_ruby_version = '>= 1.9.2'
+
+  s.add_dependency('multi_json', '>= 1.15.0')
+
+  s.add_development_dependency('rake', '>= 13.2.1')
+  s.add_development_dependency('rspec', '>= 3.13.0')
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+end

data/spec/mangopay/acquiring_spec.rb

@@ -0,0 +1,176 @@
+xdescribe MangoPay::Hook do
+  include_context 'wallets'
+  include_context 'payins'
+
+  let(:card_id) { 'placeholder' }
+
+  describe 'PAY_IN CARD DIRECT' do
+    it 'creates a Card Direct PayIn' do
+      created = create_new_pay_in_card_direct
+
+      assert_common_pay_in_properties(created)
+      expect(created['PaymentType']).to eq('CARD')
+      expect(created['ExecutionType']).to eq('DIRECT')
+    end
+  end
+
+  describe 'REFUND' do
+    it 'creates a Refund for a PayIn' do
+      pay_in = create_new_pay_in_card_direct
+      refund = MangoPay::Acquiring::Refund.create(pay_in['Id'], { DebitedFunds: { Currency: 'EUR', Amount: 10 } })
+
+      expect(refund['Id']).not_to be_nil
+      expect(refund['Status']).to eq('SUCCEEDED')
+      expect(refund['Type']).to eq('PAYOUT')
+      expect(refund['Nature']).to eq('REFUND')
+      expect(refund['InitialTransactionType']).to eq('PAYIN')
+      expect(refund['InitialTransactionId']).to eq(pay_in['Id'])
+    end
+  end
+
+  describe 'PAY_IN APPLE_PAY' do
+    it 'creates an ApplePay direct PayIn' do
+      created = MangoPay::Acquiring::PayIn::ApplePay::Direct.create(
+        DebitedFunds: { Currency: 'EUR', Amount: 100 },
+        PaymentData: {
+          transactionId: "97e64d87f13a89ff6443cdcc205d5ccf7e15368b0d64126a8a2e0888a3a5c2a0",
+          network: "MasterCard",
+          tokenDataø: "{\"data\":\"2TihgKbmyPje02.........wAAAAAAAA==\",\"header\":{\"publicKeyHash\":\"xUyeFb75d359bfPEiq2JJMQj694UAxtTuBsaTWMOJxQ=\",\"ephemeralPublicKey\":\"MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkeuICjZ7x15b7hPEBEBT5Zp43l95wCmJCU3QNxBvOCusG9w9sJMULuXlT4K8LOlPgaZzAcyWlfNwnLivVdOPfg==\",\"transactionId\":\"97e64d87f13a89ff6443cdcc205d5ccf7e15368b0d64126a8a2e0888a3a5c2a0\"},\"version\":\"EC_v1\"}"
+        }
+      )
+
+      assert_common_pay_in_properties(created)
+      expect(created['PaymentType']).to eq('APPLEPAY')
+      expect(created['ExecutionType']).to eq('DIRECT')
+    end
+  end
+
+  describe 'PAY_IN GOOGLE_PAY' do
+    it 'creates a GooglePay direct PayIn' do
+      created = MangoPay::Acquiring::PayIn::GooglePay::Direct.create(
+        DebitedFunds: { Currency: 'EUR', Amount: 199 },
+        IpAddress: "2001:0620:0000:0000:0211:24FF:FE80:C12C",
+        SecureModeReturnURL: 'http://test.com',
+        BrowserInfo: {
+          AcceptHeader: "text/html, application/xhtml+xml, application/xml;q=0.9, /;q=0.8",
+          JavaEnabled: true,
+          Language: "fr-FR",
+          ColorDepth: 4,
+          ScreenHeight: 1800,
+          ScreenWidth: 400,
+          JavascriptEnabled: true,
+          TimeZoneOffset: "+60",
+          UserAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 13_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148"
+        },
+        PaymentData: "{\"signature\":\"MEUCIQDc49/Bw1lTk8ok2fUe4UT......................\\u003d\\\"}\"}"
+      )
+
+      assert_common_pay_in_properties(created)
+      expect(created['PaymentType']).to eq('GOOGLEPAY')
+      expect(created['ExecutionType']).to eq('DIRECT')
+    end
+  end
+
+  describe 'PAY_IN IDEAL WEB' do
+    it 'creates an Ideal Web PayIn' do
+      created = MangoPay::Acquiring::PayIn::Ideal::Web.create(
+        DebitedFunds: { Currency: 'EUR', Amount: 100 },
+        ReturnURL: 'http://www.my-site.com/returnURL'
+      )
+
+      assert_common_pay_in_properties(created)
+      expect(created['PaymentType']).to eq('IDEAL')
+      expect(created['ExecutionType']).to eq('WEB')
+    end
+  end
+
+  describe 'PAY_IN PAYPAL' do
+    it 'creates a PayPal Web PayIn' do
+      created = MangoPay::Acquiring::PayIn::PayPal::Web.create(
+        DebitedFunds: { Currency: 'EUR', Amount: 400 },
+        ReturnUrl: "http://example.com",
+        LineItems: [
+          {
+            Name: "running shoes",
+            Quantity: 1,
+            UnitAmount: 200,
+            TaxAmount: 0,
+            Description: "seller1 ID"
+          },
+          {
+            Name: "running shoes",
+            Quantity: 1,
+            UnitAmount: 200,
+            TaxAmount: 0,
+            Description: "seller2 ID"
+          }
+        ]
+      )
+
+      assert_common_pay_in_properties(created)
+      expect(created['PaymentType']).to eq('PAYPAL')
+      expect(created['ExecutionType']).to eq('WEB')
+    end
+
+    it 'creates PayPal DataCollection' do
+      data_collection = MangoPay::Acquiring::PayIn::PayPal::Web.create_data_collection(
+        {
+          "sender_account_id": "A12345N343",
+          "sender_first_name": "Jane",
+          "sender_last_name": "Doe",
+          "sender_email": "jane.doe@sample.com",
+          "sender_phone": "(042)11234567",
+          "sender_address_zip": "75009",
+          "sender_country_code": "FR",
+          "sender_create_date": "2012-12-09T19:14:55.277-0:00",
+          "sender_signup_ip": "10.220.90.20",
+          "sender_popularity_score": "high",
+          "receiver_account_id": "A12345N344",
+          "receiver_create_date": "2012-12-09T19:14:55.277-0:00",
+          "receiver_email": "jane@sample.com",
+          "receiver_address_country_code": "FR",
+          "business_name": "Jane Ltd",
+          "recipient_popularity_score": "high",
+          "first_interaction_date": "2012-12-09T19:14:55.277-0:00",
+          "txn_count_total": "34",
+          "vertical": "Household goods",
+          "transaction_is_tangible": "0"
+        }
+      )
+      expect(data_collection['dataCollectionId']).not_to be_nil
+    end
+  end
+
+  def create_new_pay_in_card_direct
+    MangoPay::Acquiring::PayIn::Card::Direct.create(
+      DebitedFunds: { Currency: 'EUR', Amount: 100 },
+      CardType: 'CB_VISA_MASTERCARD',
+      CardId: card_id,
+      SecureMode: 'DEFAULT',
+      SecureModeReturnURL: 'http://test.com',
+      Tag: 'Acquiring Test PayIn/Card/Direct',
+      BrowserInfo: {
+        AcceptHeader: "text/html, application/xhtml+xml, application/xml;q=0.9, /;q=0.8",
+        JavaEnabled: true,
+        Language: "FR-FR",
+        ColorDepth: 4,
+        ScreenHeight: 1800,
+        ScreenWidth: 400,
+        JavascriptEnabled: true,
+        TimeZoneOffset: "+60",
+        UserAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 13_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148"
+      },
+      IpAddress: "2001:0620:0000:0000:0211:24FF:FE80:C12C"
+    )
+  end
+
+  def assert_common_pay_in_properties(pay_in)
+    expect(pay_in['Id']).not_to be_nil
+    expect(pay_in['Type']).to eq('PAYIN')
+    expect(pay_in['Nature']).to eq('REGULAR')
+    expect(pay_in['Status']).to eq('SUCCEEDED')
+    expect(pay_in['ResultCode']).to eq('000000')
+    expect(pay_in['ResultMessage']).to eq('Success')
+    expect(pay_in['ExecutionDate']).to be > 0
+  end
+end