activemerchant 1.79.2 → 1.129.0

data/lib/active_merchant/billing/gateways/payeezy.rb

@@ -11,7 +11,7 @@ module ActiveMerchant
       self.money_format = :cents
       self.supported_countries = %w(US CA)
 
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club]
+      self.supported_cardtypes = %i[visa master american_express discover jcb diners_club]
 
       self.homepage_url = 'https://developer.payeezy.com/'
       self.display_name = 'Payeezy'
@@ -34,28 +34,36 @@ module ActiveMerchant
         params = payment_method.is_a?(String) ? { transaction_type: 'recurring' } : { transaction_type: 'purchase' }
 
         add_invoice(params, options)
+        add_reversal_id(params, options)
         add_payment_method(params, payment_method, options)
         add_address(params, options)
         add_amount(params, amount, options)
         add_soft_descriptors(params, options)
+        add_level2_data(params, options)
+        add_stored_credentials(params, options)
+        add_external_three_ds(params, payment_method, options)
 
         commit(params, options)
       end
 
       def authorize(amount, payment_method, options = {})
-        params = {transaction_type: 'authorize'}
+        params = { transaction_type: 'authorize' }
 
         add_invoice(params, options)
+        add_reversal_id(params, options)
         add_payment_method(params, payment_method, options)
         add_address(params, options)
         add_amount(params, amount, options)
         add_soft_descriptors(params, options)
+        add_level2_data(params, options)
+        add_stored_credentials(params, options)
+        add_external_three_ds(params, payment_method, options)
 
         commit(params, options)
       end
 
       def capture(amount, authorization, options = {})
-        params = {transaction_type: 'capture'}
+        params = { transaction_type: 'capture' }
 
         add_authorization_info(params, authorization)
         add_amount(params, amount, options)
@@ -65,16 +73,28 @@ module ActiveMerchant
       end
 
       def refund(amount, authorization, options = {})
-        params = {transaction_type: 'refund'}
+        params = { transaction_type: 'refund' }
 
         add_authorization_info(params, authorization)
         add_amount(params, (amount || amount_from_authorization(authorization)), options)
+        add_soft_descriptors(params, options)
+        add_invoice(params, options)
+
+        commit(params, options)
+      end
+
+      def credit(amount, payment_method, options = {})
+        params = { transaction_type: 'refund' }
 
+        add_amount(params, amount, options)
+        add_payment_method(params, payment_method, options)
+        add_soft_descriptors(params, options)
+        add_invoice(params, options)
         commit(params, options)
       end
 
       def store(payment_method, options = {})
-        params = {transaction_type: 'store'}
+        params = { transaction_type: 'store' }
 
         add_creditcard_for_tokenization(params, payment_method, options)
 
@@ -82,17 +102,17 @@ module ActiveMerchant
       end
 
       def void(authorization, options = {})
-        params = {transaction_type: 'void'}
+        params = { transaction_type: 'void' }
 
-        add_authorization_info(params, authorization)
+        add_authorization_info(params, authorization, options)
         add_amount(params, amount_from_authorization(authorization), options)
 
         commit(params, options)
       end
 
-      def verify(credit_card, options={})
+      def verify(credit_card, options = {})
         MultiResponse.run(:use_first_response) do |r|
-          r.process { authorize(100, credit_card, options) }
+          r.process { authorize(0, credit_card, options) }
           r.process(:ignore_result) { void(r.authorization, options) }
         end
       end
@@ -107,6 +127,7 @@ module ActiveMerchant
           gsub(%r((Apikey: )(\w|-)+), '\1[FILTERED]').
           gsub(%r((\\?"card_number\\?":\\?")\d+), '\1[FILTERED]').
           gsub(%r((\\?"cvv\\?":\\?")\d+), '\1[FILTERED]').
+          gsub(%r((\\?"cvv\\?":\\?)\d+), '\1[FILTERED]').
           gsub(%r((\\?"account_number\\?":\\?")\d+), '\1[FILTERED]').
           gsub(%r((\\?"routing_number\\?":\\?")\d+), '\1[FILTERED]').
           gsub(%r((\\?card_number=)\d+(&?)), '\1[FILTERED]').
@@ -114,24 +135,57 @@ module ActiveMerchant
           gsub(%r((\\?apikey=)\w+(&?)), '\1[FILTERED]').
           gsub(%r{(\\?"credit_card\.card_number\\?":)(\\?"[^"]+\\?")}, '\1[FILTERED]').
           gsub(%r{(\\?"credit_card\.cvv\\?":)(\\?"[^"]+\\?")}, '\1[FILTERED]').
-          gsub(%r{(\\?"apikey\\?":)(\\?"[^"]+\\?")}, '\1[FILTERED]')
+          gsub(%r{(\\?"apikey\\?":)(\\?"[^"]+\\?")}, '\1[FILTERED]').
+          gsub(%r{(\\?"cavv\\?":)(\\?"[^"]+\\?")}, '\1[FILTERED]').
+          gsub(%r{(\\?"xid\\?":)(\\?"[^"]+\\?")}, '\1[FILTERED]')
       end
 
       private
 
+      def add_external_three_ds(params, payment_method, options)
+        return unless three_ds = options[:three_d_secure]
+
+        params[:'3DS'] = {
+          program_protocol: three_ds[:version][0],
+          directory_server_transaction_id: three_ds[:ds_transaction_id],
+          cardholder_name: payment_method.name,
+          card_number: payment_method.number,
+          exp_date: format_exp_date(payment_method.month, payment_method.year),
+          cvv: payment_method.verification_value,
+          xid: three_ds[:acs_transaction_id],
+          cavv: three_ds[:cavv],
+          wallet_provider_id: 'NO_WALLET',
+          type: 'D'
+        }.compact
+
+        params[:eci_indicator] = options[:three_d_secure][:eci]
+        params[:method] = '3DS'
+      end
+
       def add_invoice(params, options)
         params[:merchant_ref] = options[:order_id]
       end
 
+      def add_reversal_id(params, options)
+        params[:reversal_id] = options[:reversal_id] if options[:reversal_id]
+      end
+
       def amount_from_authorization(authorization)
         authorization.split('|').last.to_i
       end
 
-      def add_authorization_info(params, authorization)
-        transaction_id, transaction_tag, method, _ = authorization.split('|')
-        params[:transaction_id] = transaction_id
-        params[:transaction_tag] = transaction_tag
-        params[:method] = (method == 'token') ? 'credit_card' : method
+      def add_authorization_info(params, authorization, options = {})
+        transaction_id, transaction_tag, method, = authorization.split('|')
+        params[:method] = method == 'token' ? 'credit_card' : method
+        # If the previous transaction `method` value was 3DS, it needs to be set to `credit_card` on follow up transactions
+        params[:method] = 'credit_card' if method == '3DS'
+
+        if options[:reversal_id]
+          params[:reversal_id] = options[:reversal_id]
+        else
+          params[:transaction_id] = transaction_id
+          params[:transaction_tag] = transaction_tag
+        end
       end
 
       def add_creditcard_for_tokenization(params, payment_method, options)
@@ -142,7 +196,7 @@ module ActiveMerchant
         params[:auth] = 'false'
       end
 
-      def is_store_action?(params)
+      def store_action?(params)
         params[:transaction_type] == 'store'
       end
 
@@ -151,6 +205,8 @@ module ActiveMerchant
           add_echeck(params, payment_method, options)
         elsif payment_method.is_a? String
           add_token(params, payment_method, options)
+        elsif payment_method.is_a? NetworkTokenizationCreditCard
+          add_network_tokenization(params, payment_method, options)
         else
           add_creditcard(params, payment_method)
         end
@@ -159,11 +215,11 @@ module ActiveMerchant
       def add_echeck(params, echeck, options)
         tele_check = {}
 
-        tele_check[:check_number] = echeck.number || "001"
-        tele_check[:check_type] = "P"
+        tele_check[:check_number] = echeck.number || '001'
+        tele_check[:check_type] = 'P'
         tele_check[:routing_number] = echeck.routing_number
         tele_check[:account_number] = echeck.account_number
-        tele_check[:accountholder_name] = "#{echeck.first_name} #{echeck.last_name}"
+        tele_check[:accountholder_name] = name_from_payment_method(echeck)
         tele_check[:customer_id_type] = options[:customer_id_type] if options[:customer_id_type]
         tele_check[:customer_id_number] = options[:customer_id_number] if options[:customer_id_number]
         tele_check[:client_email] = options[:client_email] if options[:client_email]
@@ -206,10 +262,37 @@ module ActiveMerchant
         card
       end
 
+      def add_network_tokenization(params, payment_method, options)
+        nt_card = {}
+        nt_card[:type] = 'D'
+        nt_card[:cardholder_name] = name_from_payment_method(payment_method) || name_from_address(options)
+        nt_card[:card_number] = payment_method.number
+        nt_card[:exp_date] = format_exp_date(payment_method.month, payment_method.year)
+        nt_card[:cvv] = payment_method.verification_value
+        nt_card[:xid] = payment_method.payment_cryptogram unless payment_method.payment_cryptogram.empty? || payment_method.brand.include?('american_express')
+        nt_card[:cavv] = payment_method.payment_cryptogram unless payment_method.payment_cryptogram.empty?
+        nt_card[:wallet_provider_id] = 'APPLE_PAY'
+
+        params['3DS'] = nt_card
+        params[:method] = '3DS'
+        params[:eci_indicator] = payment_method.eci.nil? ? '5' : payment_method.eci
+      end
+
       def format_exp_date(month, year)
         "#{format(month, :two_digits)}#{format(year, :two_digits)}"
       end
 
+      def name_from_address(options)
+        return unless address = options[:billing_address]
+        return address[:name] if address[:name]
+      end
+
+      def name_from_payment_method(payment_method)
+        return unless payment_method.first_name && payment_method.last_name
+
+        return "#{payment_method.first_name} #{payment_method.last_name}"
+      end
+
       def add_address(params, options)
         address = options[:billing_address]
         return unless address
@@ -233,6 +316,41 @@ module ActiveMerchant
         params[:soft_descriptors] = options[:soft_descriptors] if options[:soft_descriptors]
       end
 
+      def add_level2_data(params, options)
+        return unless level2_data = options[:level2]
+
+        params[:level2] = {}
+        params[:level2][:customer_ref] = level2_data[:customer_ref]
+      end
+
+      def add_stored_credentials(params, options)
+        if options[:sequence] || options[:stored_credential]
+          params[:stored_credentials] = {}
+          params[:stored_credentials][:cardbrand_original_transaction_id] = original_transaction_id(options) if original_transaction_id(options)
+          params[:stored_credentials][:initiator] = initiator(options) if initiator(options)
+          params[:stored_credentials][:sequence] = options[:sequence] || sequence(options[:stored_credential][:initial_transaction])
+          params[:stored_credentials][:is_scheduled] = options[:is_scheduled] || is_scheduled(options[:stored_credential][:reason_type])
+          params[:stored_credentials][:auth_type_override] = options[:auth_type_override] if options[:auth_type_override]
+        end
+      end
+
+      def original_transaction_id(options)
+        return options[:cardbrand_original_transaction_id] || options.dig(:stored_credential, :network_transaction_id)
+      end
+
+      def initiator(options)
+        return options[:initiator] if options[:initiator]
+        return options[:stored_credential][:initiator].upcase if options.dig(:stored_credential, :initiator)
+      end
+
+      def sequence(initial_transaction)
+        initial_transaction ? 'FIRST' : 'SUBSEQUENT'
+      end
+
+      def is_scheduled(reason_type)
+        reason_type == 'recurring' ? 'true' : 'false'
+      end
+
       def commit(params, options)
         url = base_url(options) + endpoint(params)
 
@@ -248,15 +366,16 @@ module ActiveMerchant
           response = json_error(e.response.body)
         end
 
+        success = success_from(response)
         Response.new(
-          success_from(response),
-          handle_message(response, success_from(response)),
+          success,
+          handle_message(response, success),
           response,
           test: test?,
           authorization: authorization_from(params, response),
-          avs_result: {code: response['avs']},
+          avs_result: { code: response['avs'] },
           cvv_result: response['cvv2'],
-          error_code: error_code(response, success_from(response))
+          error_code: success ? nil : error_code_from(response)
         )
       end
 
@@ -271,7 +390,7 @@ module ActiveMerchant
       end
 
       def endpoint(params)
-        is_store_action?(params) ? '/transactions/tokens' : '/transactions'
+        store_action?(params) ? '/transactions/tokens' : '/transactions'
       end
 
       def api_request(url, params)
@@ -281,7 +400,8 @@ module ActiveMerchant
 
       def post_data(params)
         return nil unless params
-        params.reject { |k, v| v.blank? }.collect { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }.join("&")
+
+        params.reject { |_k, v| v.blank? }.collect { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }.join('&')
       end
 
       def generate_hmac(nonce, current_timestamp, payload)
@@ -291,7 +411,7 @@ module ActiveMerchant
           current_timestamp.to_s,
           @options[:token],
           payload
-        ].join("")
+        ].join('')
         hash = Base64.strict_encode64(OpenSSL::HMAC.hexdigest('sha256', @options[:apisecret], message))
         hash
       end
@@ -309,9 +429,16 @@ module ActiveMerchant
         }
       end
 
-      def error_code(response, success)
-        return if success
-        response['Error'].to_h['messages'].to_a.map { |e| e['code'] }.join(', ')
+      def error_code_from(response)
+        error_code = nil
+        if response['bank_resp_code'] == '100'
+          return
+        elsif response['bank_resp_code']
+          error_code = response['bank_resp_code']
+        elsif error_code = response['Error'].to_h['messages'].to_a.map { |e| e['code'] }.join(', ')
+        end
+
+        error_code
       end
 
       def success_from(response)
@@ -347,7 +474,7 @@ module ActiveMerchant
       end
 
       def authorization_from(params, response)
-        if is_store_action?(params)
+        if store_action?(params)
           if success_from(response)
             [
               response['token']['type'],
@@ -363,7 +490,7 @@ module ActiveMerchant
             response['transaction_id'],
             response['transaction_tag'],
             params[:method],
-            (response['amount'] && response['amount'].to_i)
+            response['amount']&.to_i
           ].join('|')
         end
       end
@@ -379,7 +506,7 @@ module ActiveMerchant
       end
 
       def json_error(raw_response)
-        {"error" => "Unable to parse response: #{raw_response.inspect}"}
+        { 'error' => "Unable to parse response: #{raw_response.inspect}" }
       end
     end
   end

data/lib/active_merchant/billing/gateways/payex.rb

@@ -1,4 +1,4 @@
-require "nokogiri"
+require 'nokogiri'
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
@@ -12,11 +12,11 @@ module ActiveMerchant #:nodoc:
       self.test_confined_url = 'https://test-confined.payex.com/'
 
       self.money_format = :cents
-      self.supported_countries = ['DK', 'FI', 'NO', 'SE']
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.supported_countries = %w[DK FI NO SE]
+      self.supported_cardtypes = %i[visa master american_express discover]
       self.homepage_url = 'http://payex.com/'
       self.display_name = 'Payex'
-      self.default_currency = "EUR"
+      self.default_currency = 'EUR'
 
       TRANSACTION_STATUS = {
         sale:       '0',
@@ -25,18 +25,18 @@ module ActiveMerchant #:nodoc:
         authorize:  '3',
         cancel:     '4',
         failure:    '5',
-        capture:    '6',
+        capture:    '6'
       }
 
       SOAP_ACTIONS = {
         initialize: { name: 'Initialize8', url: 'pxorder/pxorder.asmx', xmlns: 'http://external.payex.com/PxOrder/' },
-        purchasecc: { name: 'PurchaseCC', url: 'pxconfined/pxorder.asmx', xmlns: 'http://confined.payex.com/PxOrder/', confined: true},
+        purchasecc: { name: 'PurchaseCC', url: 'pxconfined/pxorder.asmx', xmlns: 'http://confined.payex.com/PxOrder/', confined: true },
         cancel: { name: 'Cancel2', url: 'pxorder/pxorder.asmx', xmlns: 'http://external.payex.com/PxOrder/' },
         capture: { name: 'Capture5', url: 'pxorder/pxorder.asmx', xmlns: 'http://external.payex.com/PxOrder/' },
         credit: { name: 'Credit5', url: 'pxorder/pxorder.asmx', xmlns: 'http://external.payex.com/PxOrder/' },
         create_agreement: { name: 'CreateAgreement3', url: 'pxagreement/pxagreement.asmx', xmlns: 'http://external.payex.com/PxAgreement/' },
         delete_agreement: { name: 'DeleteAgreement', url: 'pxagreement/pxagreement.asmx', xmlns: 'http://external.payex.com/PxAgreement/' },
-        autopay: { name: 'AutoPay3', url: 'pxagreement/pxagreement.asmx', xmlns: 'http://external.payex.com/PxAgreement/' },
+        autopay: { name: 'AutoPay3', url: 'pxagreement/pxagreement.asmx', xmlns: 'http://external.payex.com/PxAgreement/' }
       }
 
       def initialize(options = {})
@@ -63,14 +63,13 @@ module ActiveMerchant #:nodoc:
         if payment_method.respond_to?(:number)
           # credit card authorization
           MultiResponse.new.tap do |r|
-            r.process {send_initialize(amount, true, options)}
-            r.process {send_purchasecc(payment_method, r.params['orderref'])}
+            r.process { send_initialize(amount, true, options) }
+            r.process { send_purchasecc(payment_method, r.params['orderref']) }
           end
         else
           # stored authorization
           send_autopay(amount, payment_method, true, options)
         end
-
       end
 
       # Public: Send a purchase Payex request
@@ -92,8 +91,8 @@ module ActiveMerchant #:nodoc:
         if payment_method.respond_to?(:number)
           # credit card purchase
           MultiResponse.new.tap do |r|
-            r.process {send_initialize(amount, false, options)}
-            r.process {send_purchasecc(payment_method, r.params['orderref'])}
+            r.process { send_initialize(amount, false, options) }
+            r.process { send_purchasecc(payment_method, r.params['orderref']) }
           end
         else
           # stored purchase
@@ -118,7 +117,7 @@ module ActiveMerchant #:nodoc:
       # options        - A standard ActiveMerchant options hash
       #
       # Returns an ActiveMerchant::Billing::Response object
-      def void(authorization, options={})
+      def void(authorization, options = {})
         send_cancel(authorization)
       end
 
@@ -155,10 +154,10 @@ module ActiveMerchant #:nodoc:
         requires!(options, :order_id)
         amount = amount(1) # 1 cent for authorization
         MultiResponse.run(:first) do |r|
-          r.process {send_create_agreement(options)}
-          r.process {send_initialize(amount, true, options.merge({agreement_ref: r.authorization}))}
+          r.process { send_create_agreement(options) }
+          r.process { send_initialize(amount, true, options.merge({ agreement_ref: r.authorization })) }
           order_ref = r.params['orderref']
-          r.process {send_purchasecc(creditcard, order_ref)}
+          r.process { send_purchasecc(creditcard, order_ref) }
         end
       end
 
@@ -194,9 +193,9 @@ module ActiveMerchant #:nodoc:
           cancelUrl: nil,
           clientLanguage: nil
         }
-        hash_fields = [:accountNumber, :purchaseOperation, :price, :priceArgList, :currency, :vat, :orderID,
-                       :productNumber, :description, :clientIPAddress, :clientIdentifier, :additionalValues,
-                       :externalID, :returnUrl, :view, :agreementRef, :cancelUrl, :clientLanguage]
+        hash_fields = %i[accountNumber purchaseOperation price priceArgList currency vat orderID
+                         productNumber description clientIPAddress clientIdentifier additionalValues
+                         externalID returnUrl view agreementRef cancelUrl clientLanguage]
         add_request_hash(properties, hash_fields)
         soap_action = SOAP_ACTIONS[:initialize]
         request = build_xml_request(soap_action, properties)
@@ -214,8 +213,8 @@ module ActiveMerchant #:nodoc:
           cardHolderName: payment_method.name,
           cardNumberCVC: payment_method.verification_value
         }
-        hash_fields = [:accountNumber, :orderRef, :transactionType, :cardNumber, :cardNumberExpireMonth,
-                       :cardNumberExpireYear, :cardNumberCVC, :cardHolderName]
+        hash_fields = %i[accountNumber orderRef transactionType cardNumber cardNumberExpireMonth
+                         cardNumberExpireYear cardNumberCVC cardHolderName]
         add_request_hash(properties, hash_fields)
 
         soap_action = SOAP_ACTIONS[:purchasecc]
@@ -232,9 +231,9 @@ module ActiveMerchant #:nodoc:
           description: options[:description] || options[:order_id],
           orderId: options[:order_id],
           purchaseOperation: is_auth ? 'AUTHORIZATION' : 'SALE',
-          currency: (options[:currency] || default_currency),
+          currency: (options[:currency] || default_currency)
         }
-        hash_fields = [:accountNumber, :agreementRef, :price, :productNumber, :description, :orderId, :purchaseOperation, :currency]
+        hash_fields = %i[accountNumber agreementRef price productNumber description orderId purchaseOperation currency]
         add_request_hash(properties, hash_fields)
 
         soap_action = SOAP_ACTIONS[:autopay]
@@ -251,7 +250,7 @@ module ActiveMerchant #:nodoc:
           vatAmount: options[:vat_amount] || 0,
           additionalValues: ''
         }
-        hash_fields = [:accountNumber, :transactionNumber, :amount, :orderId, :vatAmount, :additionalValues]
+        hash_fields = %i[accountNumber transactionNumber amount orderId vatAmount additionalValues]
         add_request_hash(properties, hash_fields)
 
         soap_action = SOAP_ACTIONS[:capture]
@@ -268,7 +267,7 @@ module ActiveMerchant #:nodoc:
           vatAmount: options[:vat_amount] || 0,
           additionalValues: ''
         }
-        hash_fields = [:accountNumber, :transactionNumber, :amount, :orderId, :vatAmount, :additionalValues]
+        hash_fields = %i[accountNumber transactionNumber amount orderId vatAmount additionalValues]
         add_request_hash(properties, hash_fields)
 
         soap_action = SOAP_ACTIONS[:credit]
@@ -279,9 +278,9 @@ module ActiveMerchant #:nodoc:
       def send_cancel(transaction_number)
         properties = {
           accountNumber: @options[:account],
-          transactionNumber: transaction_number,
+          transactionNumber: transaction_number
         }
-        hash_fields = [:accountNumber, :transactionNumber]
+        hash_fields = %i[accountNumber transactionNumber]
         add_request_hash(properties, hash_fields)
 
         soap_action = SOAP_ACTIONS[:cancel]
@@ -300,7 +299,7 @@ module ActiveMerchant #:nodoc:
           startDate: options[:startDate] || '',
           stopDate: options[:stopDate] || ''
         }
-        hash_fields = [:accountNumber, :merchantRef, :description, :purchaseOperation, :maxAmount, :notifyUrl, :startDate, :stopDate]
+        hash_fields = %i[accountNumber merchantRef description purchaseOperation maxAmount notifyUrl startDate stopDate]
         add_request_hash(properties, hash_fields)
 
         soap_action = SOAP_ACTIONS[:create_agreement]
@@ -311,9 +310,9 @@ module ActiveMerchant #:nodoc:
       def send_delete_agreement(authorization)
         properties = {
           accountNumber: @options[:account],
-          agreementRef: authorization,
+          agreementRef: authorization
         }
-        hash_fields = [:accountNumber, :agreementRef]
+        hash_fields = %i[accountNumber agreementRef]
         add_request_hash(properties, hash_fields)
 
         soap_action = SOAP_ACTIONS[:delete_agreement]
@@ -342,9 +341,9 @@ module ActiveMerchant #:nodoc:
 
       def build_xml_request(soap_action, properties)
         builder = Nokogiri::XML::Builder.new
-        builder.__send__('soap12:Envelope', {'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+        builder.__send__('soap12:Envelope', { 'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
                                              'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
-                                             'xmlns:soap12' => 'http://www.w3.org/2003/05/soap-envelope'}) do |root|
+                                             'xmlns:soap12' => 'http://www.w3.org/2003/05/soap-envelope' }) do |root|
           root.__send__('soap12:Body') do |body|
             body.__send__(soap_action[:name], xmlns: soap_action[:xmlns]) do |doc|
               properties.each do |key, val|
@@ -360,12 +359,12 @@ module ActiveMerchant #:nodoc:
         response = {}
 
         xmldoc = Nokogiri::XML(xml)
-        body = xmldoc.xpath("//soap:Body/*[1]")[0].inner_text
+        body = xmldoc.xpath('//soap:Body/*[1]')[0].inner_text
 
         doc = Nokogiri::XML(body)
 
-        doc.root.xpath("*").each do |node|
-          if (node.elements.size == 0)
+        doc.root&.xpath('*')&.each do |node|
+          if node.elements.size == 0
             response[node.name.downcase.to_sym] = node.text
           else
             node.elements.each do |childnode|
@@ -373,7 +372,7 @@ module ActiveMerchant #:nodoc:
               response[name.to_sym] = childnode.text
             end
           end
-        end unless doc.root.nil?
+        end
 
         response
       end
@@ -387,11 +386,10 @@ module ActiveMerchant #:nodoc:
         }
         response = parse(ssl_post(url, request, headers))
         Response.new(success?(response),
-                     message_from(response),
-                     response,
-                     test: test?,
-                     authorization: build_authorization(response)
-                    )
+          message_from(response),
+          response,
+          test: test?,
+          authorization: build_authorization(response))
       end
 
       def build_authorization(response)
@@ -409,4 +407,3 @@ module ActiveMerchant #:nodoc:
     end
   end
 end
-