activemerchant 1.125.0 → 1.126.0

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

@@ -50,69 +50,75 @@ module ActiveMerchant #:nodoc:
 
       def purchase(amount, credit_card, options = {})
         params = {}
-        params['amount'] = localized_amount(amount.to_f, options[:currency])
         params['authOnly'] = false
+        params['isSettleFunds'] = true
 
-        add_credit_card(params, credit_card, 'purchase', options)
-        add_type_merchant_purchase(params, @options[:merchant_id], true, options)
-        commit('purchase', params: params, jwt: options)
+        add_merchant_id(params)
+        add_amount(params, amount, options)
+        add_auth_purchase_params(params, credit_card, options)
+
+        commit('purchase', params: params)
       end
 
       def authorize(amount, credit_card, options = {})
         params = {}
-        params['amount'] = localized_amount(amount.to_f, options[:currency])
         params['authOnly'] = true
+        params['isSettleFunds'] = false
 
-        add_credit_card(params, credit_card, 'purchase', options)
-        add_type_merchant_purchase(params, @options[:merchant_id], false, options)
-        commit('purchase', params: params, jwt: options)
+        add_merchant_id(params)
+        add_amount(params, amount, options)
+        add_auth_purchase_params(params, credit_card, options)
+
+        commit('purchase', params: params)
       end
 
       def refund(amount, authorization, options = {})
         params = {}
-        params['merchantId'] = @options[:merchant_id]
-        params['paymentToken'] = get_hash(authorization)['payment_token'] || options[:payment_token]
+        add_merchant_id(params)
+        params['paymentToken'] = payment_token(authorization) || options[:payment_token]
+
         # refund amounts must be negative
         params['amount'] = ('-' + localized_amount(amount.to_f, options[:currency])).to_f
-        commit('refund', params: params, jwt: options)
+
+        commit('refund', params: params)
       end
 
       def capture(amount, authorization, options = {})
         params = {}
-        params['amount'] = localized_amount(amount.to_f, options[:currency])
-        params['authCode'] = options[:authCode]
-        params['merchantId'] = @options[:merchant_id]
-        params['paymentToken'] = get_hash(authorization)['payment_token']
-        params['shouldGetCreditCardLevel'] = true
-        params['source'] = options[:source]
-        params['tenderType'] = 'Card'
+        add_merchant_id(params)
+        add_amount(params, amount, options)
+        params['paymentToken'] = payment_token(authorization) || options[:payment_token]
+        params['tenderType'] = options[:tender_type].present? ? options[:tender_type] : 'Card'
 
-        commit('capture', params: params, jwt: options)
+        commit('capture', params: params)
       end
 
       def void(authorization, options = {})
-        commit('void', iid: get_hash(authorization)['id'], jwt: options)
+        params = {}
+
+        commit('void', params: params, iid: payment_id(authorization))
       end
 
-      def verify(credit_card, options)
-        jwt = options[:jwt_token]
+      def verify(credit_card, _options = {})
+        jwt = create_jwt.params['jwtToken']
+
         commit('verify', card_number: credit_card.number, jwt: jwt)
       end
 
-      def supports_scrubbing?
-        true
+      def get_payment_status(batch_id)
+        commit('get_payment_status', params: batch_id)
       end
 
-      def get_payment_status(batch_id, options)
-        commit('get_payment_status', params: batch_id, jwt: options)
+      def close_batch(batch_id)
+        commit('close_batch', params: batch_id)
       end
 
-      def close_batch(batch_id, options)
-        commit('close_batch', params: batch_id, jwt: options)
+      def create_jwt
+        commit('create_jwt', params: @options[:merchant_id])
       end
 
-      def create_jwt(options)
-        commit('create_jwt', params: @options[:merchant_id], jwt: options)
+      def supports_scrubbing?
+        true
       end
 
       def scrub(transcript)
@@ -122,11 +128,33 @@ module ActiveMerchant #:nodoc:
           gsub(%r((cvv\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]')
       end
 
+      private
+
+      def add_amount(params, amount, options)
+        params['amount'] = localized_amount(amount.to_f, options[:currency])
+      end
+
+      def add_merchant_id(params)
+        params['merchantId'] = @options[:merchant_id]
+      end
+
+      def add_auth_purchase_params(params, credit_card, options)
+        add_replay_id(params, options)
+        add_credit_card(params, credit_card, 'purchase', options)
+        add_purchases_data(params, options)
+        add_shipping_data(params, options)
+        add_pos_data(params, options)
+        add_additional_data(params, options)
+      end
+
+      def add_replay_id(params, options)
+        params['replayId'] = options[:replay_id] if options[:replay_id]
+      end
+
       def add_credit_card(params, credit_card, action, options)
         return unless credit_card&.is_a?(CreditCard)
 
         card_details = {}
-
         card_details['expiryMonth'] = format(credit_card.month, :two_digits).to_s
         card_details['expiryYear'] = format(credit_card.year, :two_digits).to_s
         card_details['expiryDate'] = exp_date(credit_card)
@@ -134,23 +162,8 @@ module ActiveMerchant #:nodoc:
         card_details['last4'] = credit_card.last_digits
         card_details['cvv'] = credit_card.verification_value
         card_details['number'] = credit_card.number
-
-        card_details['entryMode'] = options['entryMode'].blank? ? 'Keyed' : options['entryMode']
-
-        case action
-        when 'purchase'
-          card_details['avsStreet'] = options[:billing_address][:address1] if options[:billing_address]
-          card_details['avsZip'] =  options[:billing_address][:zip] if options[:billing_address]
-        when 'refund'
-          card_details['cardId'] = options[:card_id]
-          card_details['cardPresent'] = options[:card_present]
-          card_details['hasContract'] = options[:has_contract]
-          card_details['isCorp'] = options[:is_corp]
-          card_details['isDebit'] = options[:is_debit]
-          card_details['token'] = options[:token]
-        else
-          card_details
-        end
+        card_details['avsStreet'] = options[:billing_address][:address1] if options[:billing_address]
+        card_details['avsZip'] =  options[:billing_address][:zip] if options[:billing_address]
 
         params['cardAccount'] = card_details
       end
@@ -159,29 +172,86 @@ module ActiveMerchant #:nodoc:
         "#{format(credit_card.month, :two_digits)}/#{format(credit_card.year, :two_digits)}"
       end
 
-      def purchases
-        [{ taxRate: '0.0000', additionalTaxRate: nil, discountRate: nil }]
+      def add_additional_data(params, options)
+        params['isAuth'] = options[:is_auth].present? ? options[:is_auth] : 'true'
+        params['paymentType'] = options[:payment_type].present? ? options[:payment_type] : 'Sale'
+        params['tenderType'] = options[:tender_type].present? ? options[:tender_type] : 'Card'
+        params['taxExempt'] = options[:tax_exempt].present? ? options[:tax_exempt] : 'false'
+        params['taxAmount'] = options[:tax_amount] if options[:tax_amount]
+        params['shouldGetCreditCardLevel'] = options[:should_get_credit_card_level] if options[:should_get_credit_card_level]
+        params['source'] = options[:source] if options[:source]
+        params['invoice'] = options[:invoice] if options[:invoice]
+      end
+
+      def add_pos_data(params, options)
+        pos_data = {}
+
+        pos_data['cardholderPresence'] = options.dig(:pos_data, :cardholder_presence) || 'Ecom'
+        pos_data['deviceAttendance'] = options.dig(:pos_data, :device_attendance) || 'HomePc'
+        pos_data['deviceInputCapability'] = options.dig(:pos_data, :device_input_capability) || 'Unknown'
+        pos_data['deviceLocation'] = options.dig(:pos_data, :device_location) || 'HomePc'
+        pos_data['panCaptureMethod'] = options.dig(:pos_data, :pan_capture_method) || 'Manual'
+        pos_data['partialApprovalSupport'] = options.dig(:pos_data, :partial_approval_support) || 'NotSupported'
+        pos_data['pinCaptureCapability'] = options.dig(:pos_data, :pin_capture_capability) || 'Incapable'
+
+        params['posData'] = pos_data
+      end
+
+      def add_purchases_data(params, options)
+        return unless options[:purchases]
+
+        params['purchases'] = []
+
+        options[:purchases].each do |purchase|
+          purchase_object = {}
+
+          purchase_object['name'] = purchase[:name] if purchase[:name]
+          purchase_object['description'] = purchase[:description] if purchase[:description]
+          purchase_object['code'] = purchase[:code] if purchase[:code]
+          purchase_object['unitOfMeasure'] = purchase[:unit_of_measure] if purchase[:unit_of_measure]
+          purchase_object['unitPrice'] = purchase[:unit_price] if purchase[:unit_price]
+          purchase_object['quantity'] = purchase[:quantity] if purchase[:quantity]
+          purchase_object['taxRate'] = purchase[:tax_rate] if purchase[:tax_rate]
+          purchase_object['taxAmount'] = purchase[:tax_amount] if purchase[:tax_amount]
+          purchase_object['discountRate'] = purchase[:discount_rate] if purchase[:discount_rate]
+          purchase_object['discountAmount'] = purchase[:discount_amount] if purchase[:discount_amount]
+          purchase_object['extendedAmount'] = purchase[:extended_amount] if purchase[:extended_amount]
+          purchase_object['lineItemId'] = purchase[:line_item_id] if purchase[:line_item_id]
+
+          params['purchases'].append(purchase_object)
+        end
+      end
+
+      def add_shipping_data(params, options)
+        params['shipAmount'] = options[:ship_amount] if options[:ship_amount]
+
+        shipping_country = shipping_country_from(options)
+        params['shipToCountry'] = shipping_country if shipping_country
+
+        shipping_zip = shipping_zip_from(options)
+        params['shipToZip'] = shipping_zip if shipping_zip
+      end
+
+      def shipping_country_from(options)
+        options[:ship_to_country] || options.dig(:shipping_address, :country) || options.dig(:billing_address, :country)
+      end
+
+      def shipping_zip_from(options)
+        options[:ship_to_zip] || options.dig(:shipping_addres, :zip) || options.dig(:billing_address, :zip)
       end
 
-      def add_type_merchant_purchase(params, merchant, is_settle_funds, options)
-        params['cardPresent'] = false
-        params['cardPresentType'] = 'CardNotPresent'
-        params['isAuth'] = true
-        params['isSettleFunds'] = is_settle_funds
-        params['isTicket'] = false
+      def payment_token(authorization)
+        return unless authorization
+        return authorization unless authorization.include?('|')
 
-        params['merchantId'] = merchant
-        params['mxAdvantageEnabled'] = false
-        params['paymentType'] = 'Sale'
+        authorization.split('|').last
+      end
 
-        params['purchases'] = purchases
+      def payment_id(authorization)
+        return unless authorization
+        return authorization unless authorization.include?('|')
 
-        params['shouldGetCreditCardLevel'] = true
-        params['shouldVaultCard'] = true
-        params['source'] = options[:source]
-        params['sourceZip'] = options[:billing_address][:zip] if options[:billing_address]
-        params['taxExempt'] = false
-        params['tenderType'] = 'Card'
+        authorization.split('|').first
       end
 
       def commit(action, params: '', iid: '', card_number: nil, jwt: '')
@@ -200,10 +270,12 @@ module ActiveMerchant #:nodoc:
               parse(ssl_post(url(action, params), post_data(params), request_headers))
             end
           rescue ResponseError => e
-            parse(e.response.body)
+            # currently Priority returns a 404 with no body on certain calls. In those cases we will substitute the response status from response.message
+            gateway_response = e.response.body.presence || e.response.message
+            parse(gateway_response)
           end
+
         success = success_from(response, action)
-        response = { 'code' => '204' } if response == ''
         Response.new(
           success,
           message_from(response),
@@ -214,16 +286,6 @@ module ActiveMerchant #:nodoc:
         )
       end
 
-      def handle_response(response)
-        if response.code != '204' && (200...300).cover?(response.code.to_i)
-          response.body
-        elsif response.code == '204' || response == ''
-          response.body = { 'code' => '204' }
-        else
-          raise ResponseError.new(response)
-        end
-      end
-
       def url(action, params, ref_number: '', credit_card_number: nil)
         case action
         when 'void'
@@ -255,10 +317,22 @@ module ActiveMerchant #:nodoc:
         test? ? self.test_url_batch : self.live_url_batch
       end
 
+      def handle_response(response)
+        case response.code.to_i
+        when 204
+          { status: 'Success' }.to_json
+        when 200...300
+          response.body
+        else
+          raise ResponseError.new(response)
+        end
+      end
+
       def parse(body)
-        return body if body['code'] == '204'
+        return {} if body.blank?
 
-        JSON.parse(body)
+        parsed_response = JSON.parse(body)
+        parsed_response.is_a?(String) ? { 'message' => parsed_response } : parsed_response
       rescue JSON::ParserError
         message = 'Invalid JSON response received from Priority Gateway. Please contact Priority Gateway if you continue to receive this message.'
         message += " (The raw response returned by the API was #{body.inspect})"
@@ -268,10 +342,9 @@ module ActiveMerchant #:nodoc:
       end
 
       def success_from(response, action)
-        success = response['status'] == 'Approved' || response['status'] == 'Open' if response['status']
-        success = response['code'] == '204' if action == 'void'
-        success = !response['bank'].empty? if action == 'verify' && response['bank']
-        success
+        return !response['bank'].empty? if action == 'verify' && response['bank']
+
+        %w[Approved Open Success Settled Voided].include?(response['status'])
       end
 
       def message_from(response)
@@ -281,10 +354,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def authorization_from(response)
-        {
-          'payment_token' => response['paymentToken'],
-          'id' => response['id']
-        }
+        [response['id'], response['paymentToken']].join('|')
       end
 
       def error_from(response)
@@ -294,54 +364,6 @@ module ActiveMerchant #:nodoc:
       def post_data(params)
         params.to_json
       end
-
-      def add_pos_data(options)
-        pos_options = {}
-        pos_options['panCaptureMethod'] = options[:pan_capture_method]
-
-        pos_options
-      end
-
-      def add_purchases_data(options)
-        purchases = {}
-
-        purchases['dateCreated'] = options[:date_created]
-        purchases['iId'] = options[:i_id]
-        purchases['transactionIId'] = options[:transaction_i_id]
-        purchases['transactionId'] = options[:transaction_id]
-        purchases['name'] = options[:name]
-        purchases['description'] = options[:description]
-        purchases['code'] = options[:code]
-        purchases['unitOfMeasure'] = options[:unit_of_measure]
-        purchases['unitPrice'] = options[:unit_price]
-        purchases['quantity'] = options[:quantity]
-        purchases['taxRate'] = options[:tax_rate]
-        purchases['taxAmount'] = options[:tax_amount]
-        purchases['discountRate'] = options[:discount_rate]
-        purchases['discountAmount'] = options[:discount_amt]
-        purchases['extendedAmount'] = options[:extended_amt]
-        purchases['lineItemId'] = options[:line_item_id]
-
-        purchase_arr = []
-        purchase_arr[0] = purchases
-        purchase_arr
-      end
-
-      def add_risk_data(options)
-        risk = {}
-        risk['cvvResponseCode'] = options[:cvv_response_code]
-        risk['cvvResponse'] = options[:cvv_response]
-        risk['cvvMatch'] = options[:cvv_match]
-        risk['avsResponse'] = options[:avs_response]
-        risk['avsAddressMatch'] = options[:avs_address_match]
-        risk['avsZipMatch'] = options[:avs_zip_match]
-
-        risk
-      end
-
-      def get_hash(string)
-        JSON.parse(string.gsub('=>', ':'))
-      end
     end
   end
 end

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

@@ -0,0 +1,258 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class RapydGateway < Gateway
+      self.test_url = 'https://sandboxapi.rapyd.net/v1/'
+      self.live_url = 'https://api.rapyd.net/v1/'
+
+      self.supported_countries = %w(US BR CA CL CO DO SV MX PE PT VI AU HK IN ID JP MY NZ PH SG KR TW TH VN AD AT BE BA BG HR CY CZ DK EE FI FR GE DE GI GR GL HU IS IE IL IT LV LI LT LU MK MT MD MC ME NL GB NO PL RO RU SM SK SI ZA ES SE CH TR VA)
+      self.default_currency = 'USD'
+      self.supported_cardtypes = %i[visa master american_express discover]
+
+      self.homepage_url = 'https://www.rapyd.net/'
+      self.display_name = 'Rapyd Gateway'
+
+      STANDARD_ERROR_CODE_MAPPING = {}
+
+      def initialize(options = {})
+        requires!(options, :secret_key, :access_key)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment, options)
+        add_address(post, payment, options)
+        add_metadata(post, options)
+        add_ewallet(post, options)
+        post[:capture] = true if payment_is_card?(options)
+
+        if payment_is_ach?(options)
+          MultiResponse.run do |r|
+            r.process { commit(:post, 'payments', post) }
+            post = {}
+            post[:token] = r.authorization
+            post[:param2] = r.params.dig('data', 'original_amount').to_s
+            r.process { commit(:post, 'payments/completePayment', post) }
+          end
+        else
+          commit(:post, 'payments', post)
+        end
+      end
+
+      def authorize(money, payment, options = {})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment, options)
+        add_address(post, payment, options)
+        add_metadata(post, options)
+        add_ewallet(post, options)
+        post[:capture] = false
+        commit(:post, 'payments', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        commit(:post, "payments/#{authorization}/capture", post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {}
+        post[:payment] = authorization
+        add_invoice(post, money, options)
+        add_metadata(post, options)
+        commit(:post, 'refunds', post)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        commit(:delete, "payments/#{authorization}", post)
+      end
+
+      # Gateway returns an error if trying to run a $0 auth as invalid payment amount
+      # Gateway does not support void on a card transaction and refunds can only be done on completed transactions
+      # (such as a purchase). Authorize transactions are considered 'active' and not 'complete' until they are captured.
+      def verify(credit_card, options = {})
+        MultiResponse.run do |r|
+          r.process { purchase(100, credit_card, options) }
+          r.process { refund(100, r.authorization, options) }
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Access_key: )\w+), '\1[FILTERED]').
+          gsub(%r(("number\\?":\\?")\d+), '\1[FILTERED]').
+          gsub(%r(("cvv\\?":\\?")\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def payment_is_ach?(options)
+        return unless options[:pm_type]
+
+        return true if options[:pm_type].include?('_bank')
+      end
+
+      def payment_is_card?(options)
+        return unless options[:pm_type]
+
+        return true if options[:pm_type].include?('_card')
+      end
+
+      def add_address(post, creditcard, options)
+        return unless address = options[:address]
+
+        post[:address] = {}
+        # name and line_1 are required at the gateway
+        post[:address][:name] = address[:name] if address[:name]
+        post[:address][:line_1] = address[:address1] if address[:address1]
+        post[:address][:line_2] = address[:address2] if address[:address2]
+        post[:address][:city] = address[:city] if address[:city]
+        post[:address][:state] = address[:state] if address[:state]
+        post[:address][:country] = address[:country] if address[:country]
+        post[:address][:zip] = address[:zip] if address[:zip]
+        post[:address][:phone_number] = address[:phone] if address[:phone]
+      end
+
+      def add_invoice(post, money, options)
+        post[:amount] = amount(money).to_f.to_s
+        post[:currency] = (options[:currency] || currency(money))
+      end
+
+      def add_payment(post, payment, options)
+        if payment_is_card?(options)
+          add_creditcard(post, payment, options)
+        elsif payment_is_ach?(options)
+          add_ach(post, payment, options)
+        end
+      end
+
+      def add_creditcard(post, payment, options)
+        post[:payment_method] = {}
+        post[:payment_method][:fields] = {}
+        pm_fields = post[:payment_method][:fields]
+
+        post[:payment_method][:type] = options[:pm_type]
+        pm_fields[:number] = payment.number
+        pm_fields[:expiration_month] = payment.month.to_s
+        pm_fields[:expiration_year] = payment.year.to_s
+        pm_fields[:cvv] = payment.verification_value.to_s
+        pm_fields[:name] = "#{payment.first_name} #{payment.last_name}"
+      end
+
+      def add_ach(post, payment, options)
+        post[:payment_method] = {}
+        post[:payment_method][:fields] = {}
+
+        post[:payment_method][:type] = options[:pm_type]
+        post[:payment_method][:fields][:proof_of_authorization] = options[:proof_of_authorization]
+        post[:payment_method][:fields][:first_name] = payment.first_name if payment.first_name
+        post[:payment_method][:fields][:last_name] = payment.last_name if payment.last_name
+        post[:payment_method][:fields][:routing_number] = payment.routing_number
+        post[:payment_method][:fields][:account_number] = payment.account_number
+        post[:payment_method][:fields][:payment_purpose] = options[:payment_purpose] if options[:payment_purpose]
+      end
+
+      def add_metadata(post, options)
+        post[:metadata] = options[:metadata] if options[:metadata]
+      end
+
+      def add_ewallet(post, options)
+        post[:ewallet_id] = options[:ewallet_id] if options[:ewallet_id]
+      end
+
+      def parse(body)
+        return {} if body.empty? || body.nil?
+
+        JSON.parse(body)
+      end
+
+      def commit(method, action, parameters)
+        url = (test? ? test_url : live_url) + action.to_s
+        rel_path = "#{method}/v1/#{action}"
+        response = api_request(method, url, rel_path, parameters)
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          avs_result: avs_result(response),
+          cvv_result: cvv_result(response),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def api_request(method, url, rel_path, params)
+        params == {} ? body = '' : body = params.to_json
+        parse(ssl_request(method, url, body, headers(rel_path, body)))
+      end
+
+      def headers(rel_path, payload)
+        salt = SecureRandom.base64(12)
+        timestamp = Time.new.to_i.to_s
+        {
+          'Content-Type' => 'application/json',
+          'access_key' => @options[:access_key],
+          'salt' => salt,
+          'timestamp' => timestamp,
+          'signature' => generate_hmac(rel_path, salt, timestamp, payload)
+        }
+      end
+
+      def generate_hmac(rel_path, salt, timestamp, payload)
+        signature = "#{rel_path}#{salt}#{timestamp}#{@options[:access_key]}#{@options[:secret_key]}#{payload}"
+        hash = Base64.urlsafe_encode64(OpenSSL::HMAC.hexdigest('sha256', @options[:secret_key], signature))
+        hash
+      end
+
+      def avs_result(response)
+        return nil unless (code = response.dig('data', 'payment_method_data', 'acs_check'))
+
+        AVSResult.new(code: code)
+      end
+
+      def cvv_result(response)
+        return nil unless (code = response.dig('data', 'payment_method_data', 'cvv_check'))
+
+        CVVResult.new(code)
+      end
+
+      def success_from(response)
+        response.dig('status', 'status') == 'SUCCESS' && response.dig('status', 'error') != 'ERR'
+      end
+
+      def message_from(response)
+        case response.dig('status', 'status')
+        when 'ERROR'
+          response.dig('status', 'message') == '' ? response.dig('status', 'error_code') : response.dig('status', 'message')
+        else
+          response.dig('status', 'status')
+        end
+      end
+
+      def authorization_from(response)
+        response.dig('data') ? response.dig('data', 'id') : response.dig('status', 'operation_id')
+      end
+
+      def error_code_from(response)
+        response.dig('status', 'error_code') unless success_from(response)
+      end
+
+      def handle_response(response)
+        case response.code.to_i
+        when 200...300, 400, 401, 404
+          response.body
+        else
+          raise ResponseError.new(response)
+        end
+      end
+    end
+  end
+end

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

@@ -107,10 +107,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def verify(credit_card, options = {})
-        MultiResponse.run(:use_first_response) do |r|
-          r.process { authorize(100, credit_card, options) }
-          r.process(:ignore_result) { void(r.authorization, options) }
-        end
+        authorize(0, credit_card, options)
       end
 
       def supports_scrubbing?