activemerchant 1.126.0 → 1.129.0

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

@@ -42,6 +42,7 @@ module ActiveMerchant #:nodoc:
             add_error_on_requires_action(post, options)
             add_fulfillment_date(post, options)
             request_three_d_secure(post, options)
+            add_level_three(post, options)
 
             CREATE_INTENT_ATTRIBUTES.each do |attribute|
               add_whitelisted_attribute(post, options, attribute)
@@ -55,6 +56,11 @@ module ActiveMerchant #:nodoc:
         commit(:get, "payment_intents/#{intent_id}", nil, options)
       end
 
+      def create_test_customer
+        response = api_request(:post, 'customers')
+        response['id']
+      end
+
       def confirm_intent(intent_id, payment_method, options = {})
         post = {}
         result = add_payment_method_token(post, payment_method, options)
@@ -116,23 +122,27 @@ module ActiveMerchant #:nodoc:
       end
 
       def create_setup_intent(payment_method, options = {})
-        post = {}
-        add_customer(post, options)
-        result = add_payment_method_token(post, payment_method, options)
-        return result if result.is_a?(ActiveMerchant::Billing::Response)
+        MultiResponse.run do |r|
+          r.process do
+            post = {}
+            add_customer(post, options)
+            result = add_payment_method_token(post, payment_method, options, r)
+            return result if result.is_a?(ActiveMerchant::Billing::Response)
 
-        add_metadata(post, options)
-        add_return_url(post, options)
-        add_fulfillment_date(post, options)
-        request_three_d_secure(post, options)
-        post[:on_behalf_of] = options[:on_behalf_of] if options[:on_behalf_of]
-        post[:usage] = options[:usage] if %w(on_session off_session).include?(options[:usage])
-        post[:description] = options[:description] if options[:description]
+            add_metadata(post, options)
+            add_return_url(post, options)
+            add_fulfillment_date(post, options)
+            request_three_d_secure(post, options)
+            post[:on_behalf_of] = options[:on_behalf_of] if options[:on_behalf_of]
+            post[:usage] = options[:usage] if %w(on_session off_session).include?(options[:usage])
+            post[:description] = options[:description] if options[:description]
 
-        commit(:post, 'setup_intents', post, options)
+            commit(:post, 'setup_intents', post, options)
+          end
+        end
       end
 
-      def retrieve_setup_intent(setup_intent_id)
+      def retrieve_setup_intent(setup_intent_id, options = {})
         # Retrieving a setup_intent passing 'expand[]=latest_attempt' allows the caller to
         # check for a network_transaction_id and ds_transaction_id
         # eg (latest_attempt -> payment_method_details -> card -> network_transaction_id)
@@ -140,7 +150,7 @@ module ActiveMerchant #:nodoc:
         # Being able to retrieve these fields enables payment flows that rely on MIT exemptions, e.g: off_session
         commit(:post, "setup_intents/#{setup_intent_id}", {
           'expand[]': 'latest_attempt'
-        }, {})
+        }, options)
       end
 
       def authorize(money, payment_method, options = {})
@@ -231,7 +241,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def verify(payment_method, options = {})
-        create_setup_intent(payment_method, options.merge!(confirm: true))
+        create_setup_intent(payment_method, options.merge!({ confirm: true, verify: true }))
       end
 
       def setup_purchase(money, options = {})
@@ -284,6 +294,19 @@ module ActiveMerchant #:nodoc:
         post[:metadata][:event_type] = options[:event_type] if options[:event_type]
       end
 
+      def add_level_three(post, options = {})
+        level_three = {}
+
+        level_three[:merchant_reference] = options[:merchant_reference] if options[:merchant_reference]
+        level_three[:customer_reference] = options[:customer_reference] if options[:customer_reference]
+        level_three[:shipping_address_zip] = options[:shipping_address_zip] if options[:shipping_address_zip]
+        level_three[:shipping_from_zip] = options[:shipping_from_zip] if options[:shipping_from_zip]
+        level_three[:shipping_amount] = options[:shipping_amount] if options[:shipping_amount]
+        level_three[:line_items] = options[:line_items] if options[:line_items]
+
+        post[:level3] = level_three unless level_three.empty?
+      end
+
       def add_return_url(post, options)
         return unless options[:confirm]
 
@@ -291,7 +314,7 @@ module ActiveMerchant #:nodoc:
         post[:return_url] = options[:return_url] if options[:return_url]
       end
 
-      def add_payment_method_token(post, payment_method, options)
+      def add_payment_method_token(post, payment_method, options, responses = [])
         case payment_method
         when StripePaymentToken
           post[:payment_method_data] = {
@@ -304,7 +327,9 @@ module ActiveMerchant #:nodoc:
         when String
           extract_token_from_string_and_maybe_add_customer_id(post, payment_method)
         when ActiveMerchant::Billing::CreditCard
-          get_payment_method_data_from_card(post, payment_method, options)
+          return create_payment_method_and_extract_token(post, payment_method, options, responses) if options[:verify]
+
+          get_payment_method_data_from_card(post, payment_method, options, responses)
         end
       end
 
@@ -333,6 +358,7 @@ module ActiveMerchant #:nodoc:
             cryptogram: payment.payment_cryptogram
           }
         }
+        add_billing_address_for_card_tokenization(post, options) if %i(apple_pay android_pay).include?(tokenization_method)
         token_response = api_request(:post, 'tokens', post, options)
         success = token_response['error'].nil?
         if success && token_response['id']
@@ -344,16 +370,17 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def get_payment_method_data_from_card(post, payment_method, options)
-        return create_payment_method_and_extract_token(post, payment_method, options) unless off_session_request?(options)
+      def get_payment_method_data_from_card(post, payment_method, options, responses)
+        return create_payment_method_and_extract_token(post, payment_method, options, responses) unless off_session_request?(options)
 
         post[:payment_method_data] = add_payment_method_data(payment_method, options)
       end
 
-      def create_payment_method_and_extract_token(post, payment_method, options)
+      def create_payment_method_and_extract_token(post, payment_method, options, responses)
         payment_method_response = create_payment_method(payment_method, options)
         return payment_method_response if payment_method_response.failure?
 
+        responses << payment_method_response
         add_payment_method_token(post, payment_method_response.params['id'], options)
       end
 
@@ -448,9 +475,22 @@ module ActiveMerchant #:nodoc:
         post
       end
 
+      def add_billing_address_for_card_tokenization(post, options = {})
+        return unless (billing = options[:billing_address] || options[:address])
+
+        post[:card][:address_city] = billing[:city] if billing[:city]
+        post[:card][:address_country] = billing[:country] if billing[:country]
+        post[:card][:address_line1] = billing[:address1] if billing[:address1]
+        post[:card][:address_line2] = billing[:address2] if billing[:address2]
+        post[:card][:address_zip] = billing[:zip] if billing[:zip]
+        post[:card][:address_state] = billing[:state] if billing[:state]
+      end
+
       def add_billing_address(post, options = {})
         return unless billing = options[:billing_address] || options[:address]
 
+        email = billing[:email] || options[:email]
+
         post[:billing_details] = {}
         post[:billing_details][:address] = {}
         post[:billing_details][:address][:city] = billing[:city] if billing[:city]
@@ -459,7 +499,7 @@ module ActiveMerchant #:nodoc:
         post[:billing_details][:address][:line2] = billing[:address2] if billing[:address2]
         post[:billing_details][:address][:postal_code] = billing[:zip] if billing[:zip]
         post[:billing_details][:address][:state] = billing[:state] if billing[:state]
-        post[:billing_details][:email] = billing[:email] if billing[:email]
+        post[:billing_details][:email] = email if email
         post[:billing_details][:name] = billing[:name] if billing[:name]
         post[:billing_details][:phone] = billing[:phone] if billing[:phone]
       end
@@ -501,7 +541,7 @@ module ActiveMerchant #:nodoc:
       def success_from(response, options)
         if response['status'] == 'requires_action' && !options[:execute_threed]
           response['error'] = {}
-          response['error']['message'] = 'Received unexpected 3DS authentication response. Use the execute_threed option to initiate a proper 3DS flow.'
+          response['error']['message'] = 'Received unexpected 3DS authentication response, but a 3DS initiation flag was not included in the request.'
           return false
         end
 

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

@@ -8,13 +8,10 @@ module ActiveMerchant
       VERSION = '52'
 
       self.live_na_url = "https://secure.na.tnspayments.com/api/rest/version/#{VERSION}/"
-      self.test_na_url = "https://secure.na.tnspayments.com/api/rest/version/#{VERSION}/"
-
       self.live_ap_url = "https://secure.ap.tnspayments.com/api/rest/version/#{VERSION}/"
-      self.test_ap_url = "https://secure.ap.tnspayments.com/api/rest/version/#{VERSION}/"
-
       self.live_eu_url = "https://secure.eu.tnspayments.com/api/rest/version/#{VERSION}/"
-      self.test_eu_url = "https://secure.eu.tnspayments.com/api/rest/version/#{VERSION}/"
+
+      self.test_url = "https://secure.uat.tnspayments.com/api/rest/version/#{VERSION}/"
 
       self.display_name = 'TNS'
       self.homepage_url = 'http://www.tnsi.com/'

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

@@ -482,7 +482,7 @@ module ActiveMerchant #:nodoc:
 
         doc = Nokogiri::XML::Document.parse(request)
         merc_nodeset = doc.xpath('//v1:merc', 'v1' => V1_NAMESPACE)
-        merc_nodeset.after "<tranCode>#{TRANSACTION_CODES[action]}</tranCode>"
+        merc_nodeset.after "<v1:tranCode>#{TRANSACTION_CODES[action]}</v1:tranCode>"
         doc.root.to_xml
       end
 

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

@@ -248,6 +248,12 @@ module ActiveMerchant #:nodoc:
         commit(action, parameters)
       end
 
+      def verify(credit_card, options = {})
+        parameters = {}
+        add_creditcard(parameters, credit_card)
+        commit('verify', parameters)
+      end
+
       # recurring() a TrustCommerce account that is activated for Citadel, TrustCommerce's
       # hosted customer billing info database.
       #
@@ -476,9 +482,14 @@ module ActiveMerchant #:nodoc:
       end
 
       def authorization_from(action, data)
-        authorization = data['transid']
-        authorization = "#{authorization}|#{action}" if authorization && VOIDABLE_ACTIONS.include?(action)
-        authorization
+        case action
+        when 'store'
+          data['billingid']
+        when *VOIDABLE_ACTIONS
+          "#{data['transid']}|#{action}"
+        else
+          data['transid']
+        end
       end
 
       def split_authorization(authorization)

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

@@ -15,15 +15,24 @@ module ActiveMerchant
       self.homepage_url = 'http://vancopayments.com/'
       self.display_name = 'Vanco Payment Solutions'
 
+      SECONDS_PER_DAY = 3600 * 24
+      BUFFER_TIME_IN_SECS = 60 * 3
+
       def initialize(options = {})
         requires!(options, :user_id, :password, :client_id)
         super
       end
 
       def purchase(money, payment_method, options = {})
-        MultiResponse.run do |r|
-          r.process { login }
-          r.process { commit(purchase_request(money, payment_method, r.params['response_sessionid'], options), :response_transactionref) }
+        moment_less_than_24_hours_ago = Time.now - SECONDS_PER_DAY - BUFFER_TIME_IN_SECS
+
+        if options[:session_id] && options[:session_id][:created_at] >= moment_less_than_24_hours_ago
+          commit(purchase_request(money, payment_method, options[:session_id][:id], options), :response_transactionref)
+        else
+          MultiResponse.run do |r|
+            r.process { login }
+            r.process { commit(purchase_request(money, payment_method, r.params['response_sessionid'], options), :response_transactionref) }
+          end
         end
       end
 

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

@@ -143,7 +143,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def generate_purchase_number_stamp
-        (Time.now.to_f.round(2) * 100).to_i.to_s
+        Time.now.to_f.to_s.delete('.')[1..10] + rand(99).to_s
       end
 
       def commit(action, params, options = {})

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

@@ -27,6 +27,7 @@ module ActiveMerchant #:nodoc:
         requires!(options, :private_key, :public_key)
         @private_key = options[:private_key]
         @public_key = options[:public_key]
+        @encryption_key = OpenSSL::PKey::RSA.new(options[:encryption_key]) if options[:encryption_key]
         @shop_process_id = options[:shop_process_id] || SecureRandom.random_number(10**15)
         super
       end
@@ -114,15 +115,15 @@ module ActiveMerchant #:nodoc:
         transcript.encode('UTF-8', 'binary', undef: :replace, replace: '')
       end
 
-      private
-
       # Required to encrypt PAN data.
       def one_time_public_key
         token = generate_token('get_encription_public_key', @public_key)
         response = commit(:pci_encryption_key, token: token)
-        OpenSSL::PKey::RSA.new(response.params['encryption_key'])
+        response.params['encryption_key']
       end
 
+      private
+
       def generate_token(*elements)
         Digest::MD5.hexdigest(@private_key + elements.join)
       end
@@ -138,7 +139,9 @@ module ActiveMerchant #:nodoc:
 
         payload = { card_number: card_number, 'cvv': cvv }.to_json
 
-        post[:card_encrypted_data] = JWE.encrypt(payload, one_time_public_key)
+        encryption_key = @encryption_key || OpenSSL::PKey::RSA.new(one_time_public_key)
+
+        post[:card_encrypted_data] = JWE.encrypt(payload, encryption_key)
         post[:card_month_expiration] = format(payment.month, :two_digits)
         post[:card_year_expiration] = format(payment.year, :two_digits)
       end

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

@@ -61,12 +61,16 @@ module ActiveMerchant #:nodoc:
       end
 
       def refund(money, authorization, options = {})
-        post = { amount_in_cents: amount(money).to_i, transaction_id: authorization.to_s }
-        commit('refund', post, '/refunds_sync')
+        # post = { amount_in_cents: amount(money).to_i, transaction_id: authorization.to_s }
+        # commit('refund', post, '/refunds_sync')
+
+        # All refunds will instead be voided. This is temporary.
+        void(authorization, options, money)
       end
 
-      def void(authorization, options = {})
-        commit('void', {}, "/transactions/#{authorization}/void_sync")
+      def void(authorization, options = {}, money = nil)
+        post = money ? { amount_in_cents: amount(money).to_i } : {}
+        commit('void', post, "/transactions/#{authorization}/void_sync")
       end
 
       def supports_scrubbing?

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

@@ -144,6 +144,11 @@ module ActiveMerchant #:nodoc:
         store_request(credit_card, options)
       end
 
+      def inquire(authorization, options = {})
+        order_id = order_id_from_authorization(authorization.to_s) || options[:order_id]
+        commit('direct_inquiry', build_order_inquiry_request(order_id, options), :ok, options)
+      end
+
       def supports_scrubbing
         true
       end
@@ -237,6 +242,7 @@ module ActiveMerchant #:nodoc:
               add_sub_merchant_data(xml, options[:sub_merchant_data]) if options[:sub_merchant_data]
               add_hcg_additional_data(xml, options) if options[:hcg_additional_data]
               add_instalments_data(xml, options) if options[:instalments]
+              add_additional_data(xml, money, options) if options[:level_2_data] || options[:level_3_data]
               add_moto_flag(xml, options) if options.dig(:metadata, :manual_entry)
               add_additional_3ds_data(xml, options) if options[:execute_threed] && options[:three_ds_version] && options[:three_ds_version] =~ /^2/
               add_3ds_exemption(xml, options) if options[:exemption_type]
@@ -245,6 +251,91 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_additional_data(xml, amount, options)
+        level_two_data = options[:level_2_data] || {}
+        level_three_data = options[:level_3_data] || {}
+        level_two_and_three_data = level_two_data.merge(level_three_data).symbolize_keys
+
+        xml.branchSpecificExtension do
+          xml.purchase do
+            add_level_two_and_three_data(xml, amount, level_two_and_three_data)
+          end
+        end
+      end
+
+      def add_level_two_and_three_data(xml, amount, data)
+        xml.invoiceReferenceNumber data[:invoice_reference_number] if data.include?(:invoice_reference_number)
+        xml.customerReference data[:customer_reference] if data.include?(:customer_reference)
+        xml.cardAcceptorTaxId data[:card_acceptor_tax_id] if data.include?(:card_acceptor_tax_id)
+
+        {
+          sales_tax: 'salesTax',
+          discount_amount: 'discountAmount',
+          shipping_amount: 'shippingAmount',
+          duty_amount: 'dutyAmount'
+        }.each do |key, tag|
+          next unless data.include?(key)
+
+          xml.tag! tag do
+            data_amount = data[key].symbolize_keys
+            add_amount(xml, data_amount[:amount].to_i, data_amount)
+          end
+        end
+
+        xml.discountName data[:discount_name] if data.include?(:discount_name)
+        xml.discountCode data[:discount_code] if data.include?(:discount_code)
+
+        add_date_element(xml, 'shippingDate', data[:shipping_date]) if data.include?(:shipping_date)
+
+        if data.include?(:shipping_courier)
+          xml.shippingCourier(
+            data[:shipping_courier][:priority],
+            data[:shipping_courier][:tracking_number],
+            data[:shipping_courier][:name]
+          )
+        end
+
+        add_optional_data_level_two_and_three(xml, data)
+
+        if data.include?(:item) && data[:item].kind_of?(Array)
+          data[:item].each { |item| add_items_into_level_three_data(xml, item.symbolize_keys) }
+        elsif data.include?(:item)
+          add_items_into_level_three_data(xml, data[:item].symbolize_keys)
+        end
+      end
+
+      def add_items_into_level_three_data(xml, item)
+        xml.item do
+          xml.description item[:description] if item[:description]
+          xml.productCode item[:product_code] if item[:product_code]
+          xml.commodityCode item[:commodity_code] if item[:commodity_code]
+          xml.quantity item[:quantity] if item[:quantity]
+
+          {
+            unit_cost: 'unitCost',
+            item_total: 'itemTotal',
+            item_total_with_tax: 'itemTotalWithTax',
+            item_discount_amount: 'itemDiscountAmount',
+            tax_amount: 'taxAmount'
+          }.each do |key, tag|
+            next unless item.include?(key)
+
+            xml.tag! tag do
+              data_amount = item[key].symbolize_keys
+              add_amount(xml, data_amount[:amount].to_i, data_amount)
+            end
+          end
+        end
+      end
+
+      def add_optional_data_level_two_and_three(xml, data)
+        xml.shipFromPostalCode data[:ship_from_postal_code] if data.include?(:ship_from_postal_code)
+        xml.destinationPostalCode data[:destination_postal_code] if data.include?(:destination_postal_code)
+        xml.destinationCountryCode data[:destination_country_code] if data.include?(:destination_country_code)
+        add_date_element(xml, 'orderDate', data[:order_date].symbolize_keys) if data.include?(:order_date)
+        xml.taxExempt data[:tax_exempt] if data.include?(:tax_exempt)
+      end
+
       def order_tag_attributes(options)
         { 'orderCode' => clean_order_id(options[:order_id]), 'installationId' => options[:inst_id] || @options[:inst_id] }.reject { |_, v| !v.present? }
       end
@@ -718,9 +809,18 @@ module ActiveMerchant #:nodoc:
         resp_params = { action: action }
 
         parse_elements(doc.root, resp_params)
+        extract_issuer_response(doc.root, resp_params)
+
         resp_params
       end
 
+      def extract_issuer_response(doc, response)
+        return unless issuer_response = doc.at_xpath('//paymentService//reply//orderStatus//payment//IssuerResponseCode')
+
+        response[:issuer_response_code] = issuer_response['code']
+        response[:issuer_response_description] = issuer_response['description']
+      end
+
       def parse_elements(node, response)
         node_name = node.name.underscore
         node.attributes.each do |k, v|
@@ -743,9 +843,11 @@ module ActiveMerchant #:nodoc:
           'Content-Type' => 'text/xml',
           'Authorization' => encoded_credentials
         }
-        if options[:cookie]
-          headers['Cookie'] = options[:cookie] if options[:cookie]
-        end
+
+        # ensure cookie included on follow-up '3ds' and 'capture_request' calls, using the cookie saved from the preceding response
+        # cookie should be present in options on the 3ds and capture calls, but also still saved in the instance var in case
+        cookie = options[:cookie] || @cookie || nil
+        headers['Cookie'] = cookie if cookie
 
         headers['Idempotency-Key'] = idempotency_key if idempotency_key
         headers
@@ -761,7 +863,7 @@ module ActiveMerchant #:nodoc:
           raw[:is3DSOrder] = true
         end
         success = success_from(action, raw, success_criteria)
-        message = message_from(success, raw, success_criteria)
+        message = message_from(success, raw, success_criteria, action)
 
         Response.new(
           success,
@@ -798,7 +900,8 @@ module ActiveMerchant #:nodoc:
       def handle_response(response)
         case response.code.to_i
         when 200...300
-          @cookie = response['Set-Cookie']
+          cookie = response.header['Set-Cookie']&.match('^[^;]*')
+          @cookie = cookie[0] if cookie
           response.body
         else
           raise ResponseError.new(response)
@@ -809,10 +912,10 @@ module ActiveMerchant #:nodoc:
         success_criteria_success?(raw, success_criteria) || action_success?(action, raw)
       end
 
-      def message_from(success, raw, success_criteria)
+      def message_from(success, raw, success_criteria, action)
         return 'SUCCESS' if success
 
-        raw[:iso8583_return_code_description] || raw[:error] || required_status_message(raw, success_criteria)
+        raw[:iso8583_return_code_description] || raw[:error] || required_status_message(raw, success_criteria, action) || raw[:issuer_response_description]
       end
 
       # success_criteria can be:
@@ -829,6 +932,8 @@ module ActiveMerchant #:nodoc:
         case action
         when 'store'
           raw[:token].present?
+        when 'direct_inquiry'
+          raw[:last_event].present?
         else
           false
         end
@@ -838,8 +943,11 @@ module ActiveMerchant #:nodoc:
         raw[:iso8583_return_code_code] || raw[:error_code] || nil unless success == 'SUCCESS'
       end
 
-      def required_status_message(raw, success_criteria)
-        "A transaction status of #{success_criteria.collect { |c| "'#{c}'" }.join(' or ')} is required." if !success_criteria.include?(raw[:last_event])
+      def required_status_message(raw, success_criteria, action)
+        return if success_criteria.include?(raw[:last_event])
+        return unless %w[cancel refund inquiry credit fast_credit].include?(action)
+
+        "A transaction status of #{success_criteria.collect { |c| "'#{c}'" }.join(' or ')} is required."
       end
 
       def authorization_from(action, raw, options)

data/lib/active_merchant/billing/response.rb

@@ -85,7 +85,21 @@ module ActiveMerchant #:nodoc:
         (primary_response ? primary_response.success? : true)
       end
 
-      %w(params message test authorization avs_result cvv_result error_code emv_authorization test? fraud_review?).each do |m|
+      def avs_result
+        return @primary_response.try(:avs_result) if @use_first_response
+
+        result = responses.reverse.find { |r| r.avs_result['code'].present? }
+        result.try(:avs_result) || responses.last.try(:avs_result)
+      end
+
+      def cvv_result
+        return @primary_response.try(:cvv_result) if @use_first_response
+
+        result = responses.reverse.find { |r| r.cvv_result['code'].present? }
+        result.try(:cvv_result) || responses.last.try(:cvv_result)
+      end
+
+      %w(params message test authorization error_code emv_authorization test? fraud_review?).each do |m|
         class_eval %(
           def #{m}
             (@responses.empty? ? nil : primary_response.#{m})

data/lib/active_merchant/connection.rb

@@ -85,8 +85,6 @@ module ActiveMerchant
           result =
             case method
             when :get
-              raise ArgumentError, 'GET requests do not support a request body' if body
-
               http.get(endpoint.request_uri, headers)
             when :post
               debug body

data/lib/active_merchant/country.rb

@@ -184,6 +184,7 @@ module ActiveMerchant #:nodoc:
       { alpha2: 'KP', name: 'Korea, Democratic People\'s Republic of', alpha3: 'PRK', numeric: '408' },
       { alpha2: 'KR', name: 'Korea, Republic of', alpha3: 'KOR', numeric: '410' },
       { alpha2: 'XK', name: 'Kosovo', alpha3: 'XKX', numeric: '900' },
+      { alpha2: 'QZ', name: 'Kosovo', alpha3: 'XKX', numeric: '900' },
       { alpha2: 'KW', name: 'Kuwait', alpha3: 'KWT', numeric: '414' },
       { alpha2: 'KG', name: 'Kyrgyzstan', alpha3: 'KGZ', numeric: '417' },
       { alpha2: 'LA', name: 'Lao People\'s Democratic Republic', alpha3: 'LAO', numeric: '418' },

data/lib/active_merchant/errors.rb

@@ -23,10 +23,13 @@ module ActiveMerchant #:nodoc:
     end
 
     def to_s
-      "Failed with #{response.code} #{response.message if response.respond_to?(:message)}"
+      "Failed with #{response.code if response.respond_to?(:code)} #{response.message if response.respond_to?(:message)}"
     end
   end
 
+  class OAuthResponseError < ResponseError # :nodoc:
+  end
+
   class ClientCertificateError < ActiveMerchantError # :nodoc
   end
 

data/lib/active_merchant/version.rb

@@ -1,3 +1,3 @@
 module ActiveMerchant
-  VERSION = '1.126.0'
+  VERSION = '1.129.0'
 end