activemerchant 1.133.0 → 1.137.0

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

@@ -20,14 +20,14 @@ module ActiveMerchant #:nodoc:
       def purchase(amount, payment_method, options = {})
         MultiResponse.run() do |r|
           r.process { tokenize(amount, payment_method, options) }
-          r.process { charge(amount, r.authorization, options) }
+          r.process { charge(amount, r.authorization, options, payment_method) }
         end
       end
 
       def authorize(amount, payment_method, options = {})
         MultiResponse.run() do |r|
           r.process { tokenize(amount, payment_method, options) }
-          r.process { preauthorize(amount, r.authorization, options) }
+          r.process { preauthorize(amount, r.authorization, options, payment_method) }
         end
       end
 
@@ -48,8 +48,9 @@ module ActiveMerchant #:nodoc:
         post = {}
         post[:ticketNumber] = authorization
         add_full_response(post, options)
+        add_invoice(action, post, amount, options)
 
-        commit(action, post)
+        commit(action, post, options)
       end
 
       def void(authorization, options = {})
@@ -89,7 +90,7 @@ module ActiveMerchant #:nodoc:
         commit(action, post)
       end
 
-      def charge(amount, authorization, options)
+      def charge(amount, authorization, options, payment_method = {})
         action = 'charge'
 
         post = {}
@@ -100,11 +101,13 @@ module ActiveMerchant #:nodoc:
         add_metadata(post, options)
         add_months(post, options)
         add_deferred(post, options)
+        add_three_d_secure(post, payment_method, options)
+        add_product_details(post, options)
 
         commit(action, post)
       end
 
-      def preauthorize(amount, authorization, options)
+      def preauthorize(amount, authorization, options, payment_method = {})
         action = 'preAuthorization'
 
         post = {}
@@ -114,6 +117,7 @@ module ActiveMerchant #:nodoc:
         add_metadata(post, options)
         add_months(post, options)
         add_deferred(post, options)
+        add_three_d_secure(post, payment_method, options)
 
         commit(action, post)
       end
@@ -133,9 +137,9 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_amount_defaults(sum, money, options)
-        sum[:subtotalIva] = amount(money).to_f
+        sum[:subtotalIva] = 0
         sum[:iva] = 0
-        sum[:subtotalIva0] = 0
+        sum[:subtotalIva0] = amount(money).to_f
 
         sum[:ice] = 0 if sum[:currency] != 'COP'
       end
@@ -183,7 +187,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_full_response(post, options)
-        post[:fullResponse] = options[:full_response].to_s.casecmp('true').zero? if options[:full_response]
+        # this is the only currently accepted value for this field, previously it was 'true'
+        post[:fullResponse] = 'v2' unless options[:full_response] == 'false' || options[:full_response].blank?
       end
 
       def add_metadata(post, options)
@@ -204,6 +209,59 @@ module ActiveMerchant #:nodoc:
         }
       end
 
+      def add_product_details(post, options)
+        return unless options[:product_details]
+
+        product_items_array = []
+        options[:product_details].each do |item|
+          product_items_obj = {}
+
+          product_items_obj[:id] = item[:id] if item[:id]
+          product_items_obj[:title] = item[:title] if item[:title]
+          product_items_obj[:price] = item[:price].to_i if item[:price]
+          product_items_obj[:sku] = item[:sku] if item[:sku]
+          product_items_obj[:quantity] = item[:quantity].to_i if item[:quantity]
+
+          product_items_array << product_items_obj
+        end
+
+        product_items = {
+          product: product_items_array
+        }
+
+        post[:productDetails] = product_items
+      end
+
+      def add_three_d_secure(post, payment_method, options)
+        three_d_secure = options[:three_d_secure]
+        return unless three_d_secure.present?
+
+        post[:threeDomainSecure] = {
+          eci: three_d_secure[:eci],
+          specificationVersion: three_d_secure[:version]
+        }
+
+        if payment_method.brand == 'master'
+          post[:threeDomainSecure][:acceptRisk] = three_d_secure[:eci] == '00'
+          post[:threeDomainSecure][:ucaf] = three_d_secure[:cavv]
+          post[:threeDomainSecure][:directoryServerTransactionID] = three_d_secure[:ds_transaction_id]
+          case three_d_secure[:eci]
+          when '07'
+            post[:threeDomainSecure][:collectionIndicator] = '0'
+          when '06'
+            post[:threeDomainSecure][:collectionIndicator] = '1'
+          else
+            post[:threeDomainSecure][:collectionIndicator] = '2'
+          end
+        elsif payment_method.brand == 'visa'
+          post[:threeDomainSecure][:acceptRisk] = three_d_secure[:eci] == '07'
+          post[:threeDomainSecure][:cavv] = three_d_secure[:cavv]
+          post[:threeDomainSecure][:xid] = three_d_secure[:xid] if three_d_secure[:xid].present?
+        else
+          raise ArgumentError.new 'Kushki supports 3ds2 authentication for only Visa and Mastercard brands.'
+        end
+      end
+
       ENDPOINT = {
         'tokenize' => 'tokens',
         'charge' => 'charges',
@@ -213,10 +271,10 @@ module ActiveMerchant #:nodoc:
         'capture' => 'capture'
       }
 
-      def commit(action, params)
+      def commit(action, params, options = {})
         response =
           begin
-            parse(ssl_invoke(action, params))
+            parse(ssl_invoke(action, params, options))
           rescue ResponseError => e
             parse(e.response.body)
           end
@@ -233,9 +291,11 @@ module ActiveMerchant #:nodoc:
         )
       end
 
-      def ssl_invoke(action, params)
+      def ssl_invoke(action, params, options)
         if %w[void refund].include?(action)
-          ssl_request(:delete, url(action, params), nil, headers(action))
+          # removes ticketNumber from request for partial refunds because gateway will reject if included in request body
+          data = options[:partial_refund] == true ? post_data(params.except(:ticketNumber)) : nil
+          ssl_request(:delete, url(action, params), data, headers(action))
         else
           ssl_post(url(action, params), post_data(params), headers(action))
         end

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

@@ -263,11 +263,15 @@ module ActiveMerchant #:nodoc:
       def commit(money, creditcard, options = {})
         response = parse(ssl_post(test? ? self.test_url : self.live_url, post_data(money, creditcard, options)))
 
-        Response.new(successful?(response), response[:message], response,
+        Response.new(
+          successful?(response),
+          response[:message],
+          response,
           test: test?,
           authorization: response[:ordernum],
           avs_result: { code: response[:avs].to_s[2, 1] },
-          cvv_result: response[:avs].to_s[3, 1])
+          cvv_result: response[:avs].to_s[3, 1]
+        )
       end
 
       def successful?(response)

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

@@ -111,14 +111,15 @@ module ActiveMerchant #:nodoc:
         doc.lineItemData do
           level_3_data[:line_items].each do |line_item|
             doc.itemSequenceNumber(line_item[:item_sequence_number]) if line_item[:item_sequence_number]
-            doc.commodityCode(line_item[:commodity_code]) if line_item[:commodity_code]
             doc.itemDescription(line_item[:item_description]) if line_item[:item_description]
             doc.productCode(line_item[:product_code]) if line_item[:product_code]
             doc.quantity(line_item[:quantity]) if line_item[:quantity]
             doc.unitOfMeasure(line_item[:unit_of_measure]) if line_item[:unit_of_measure]
             doc.taxAmount(line_item[:tax_amount]) if line_item[:tax_amount]
-            doc.itemDiscountAmount(line_item[:discount_per_line_item]) unless line_item[:discount_per_line_item] < 0
-            doc.unitCost(line_item[:unit_cost]) unless line_item[:unit_cost] < 0
+            doc.lineItemTotal(line_item[:line_item_total]) if line_item[:line_item_total]
+            doc.itemDiscountAmount(line_item[:discount_per_line_item].to_i) unless line_item[:discount_per_line_item].to_i < 0
+            doc.commodityCode(line_item[:commodity_code]) if line_item[:commodity_code]
+            doc.unitCost(line_item[:unit_cost].to_i) unless line_item[:unit_cost].to_i < 0
             doc.detailTax do
               doc.taxIncludedInTotal(line_item[:tax_included_in_total]) if line_item[:tax_included_in_total]
               doc.taxAmount(line_item[:tax_amount]) if line_item[:tax_amount]
@@ -310,7 +311,15 @@ module ActiveMerchant #:nodoc:
       def add_auth_purchase_params(doc, money, payment_method, options)
         doc.orderId(truncate(options[:order_id], 24))
         doc.amount(money)
-        add_order_source(doc, payment_method, options)
+
+        if options.dig(:stored_credential, :initial_transaction) == false
+          # orderSource needs to be added at the top of doc and
+          # processingType near the end
+          source_for_subsequent_stored_credential_txns(doc, options)
+        else
+          add_order_source(doc, payment_method, options)
+        end
+
         add_billing_address(doc, payment_method, options)
         add_shipping_address(doc, payment_method, options)
         add_payment_method(doc, payment_method, options)
@@ -382,8 +391,9 @@ module ActiveMerchant #:nodoc:
             doc.track(payment_method.track_data)
           end
         elsif check?(payment_method)
+          account_type = payment_method.account_type || payment_method.account_holder_type
           doc.echeck do
-            doc.accType(payment_method.account_type.capitalize)
+            doc.accType(account_type&.capitalize)
             doc.accNum(payment_method.account_number)
             doc.routingNum(payment_method.routing_number)
             doc.checkNum(payment_method.number) if payment_method.number
@@ -409,16 +419,17 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_stored_credential_params(doc, options = {})
-        return unless options[:stored_credential]
+        return unless stored_credential = options[:stored_credential]
 
-        if options[:stored_credential][:initial_transaction]
-          add_stored_credential_params_initial(doc, options)
+        if stored_credential[:initial_transaction]
+          add_stored_credential_for_initial_txn(doc, options)
         else
-          add_stored_credential_params_used(doc, options)
+          doc.processingType("#{stored_credential[:initiator]}InitiatedCOF") if stored_credential[:reason_type] == 'unscheduled'
+          doc.originalNetworkTransactionId(stored_credential[:network_transaction_id]) if stored_credential[:initiator] == 'merchant'
         end
       end
 
-      def add_stored_credential_params_initial(doc, options)
+      def add_stored_credential_for_initial_txn(doc, options)
         case options[:stored_credential][:reason_type]
         when 'unscheduled'
           doc.processingType('initialCOF')
@@ -429,15 +440,15 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def add_stored_credential_params_used(doc, options)
-        if options[:stored_credential][:reason_type] == 'unscheduled'
-          if options[:stored_credential][:initiator] == 'merchant'
-            doc.processingType('merchantInitiatedCOF')
-          else
-            doc.processingType('cardholderInitiatedCOF')
-          end
+      def source_for_subsequent_stored_credential_txns(doc, options)
+        case options[:stored_credential][:reason_type]
+        when 'unscheduled'
+          doc.orderSource('ecommerce')
+        when 'installment'
+          doc.orderSource('installment')
+        when 'recurring'
+          doc.orderSource('recurring')
         end
-        doc.originalNetworkTransactionId(options[:stored_credential][:network_transaction_id])
       end
 
       def add_billing_address(doc, payment_method, options)
@@ -479,8 +490,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_order_source(doc, payment_method, options)
-        order_source = order_source(options)
-        if order_source
+        if order_source = options[:order_source]
           doc.orderSource(order_source)
         elsif payment_method.is_a?(NetworkTokenizationCreditCard) && payment_method.source == :apple_pay
           doc.orderSource('applepay')
@@ -493,31 +503,6 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def order_source(options = {})
-        return options[:order_source] unless options[:stored_credential]
-
-        order_source = nil
-
-        case options[:stored_credential][:reason_type]
-        when 'unscheduled'
-          if options[:stored_credential][:initiator] == 'merchant'
-            # For merchant-initiated, we should always set order source to
-            # 'ecommerce'
-            order_source = 'ecommerce'
-          else
-            # For cardholder-initiated, we rely on #add_order_source's
-            # default logic to set orderSource appropriately
-            order_source = options[:order_source]
-          end
-        when 'installment'
-          order_source = 'installment'
-        when 'recurring'
-          order_source = 'recurring'
-        end
-
-        order_source
-      end
-
       def add_pos(doc, payment_method)
         return unless payment_method.respond_to?(:track_data) && payment_method.track_data.present?
 
@@ -576,7 +561,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def success_from(kind, parsed)
-        return %w(000 001 010).any?(parsed[:response]) unless kind == :registerToken
+        return %w(000 001 010 141 142).any?(parsed[:response]) unless kind == :registerToken
 
         %w(000 801 802).include?(parsed[:response])
       end
@@ -618,11 +603,9 @@ module ActiveMerchant #:nodoc:
         }
       end
 
-      def build_xml_request
+      def build_xml_request(&block)
         builder = Nokogiri::XML::Builder.new
-        builder.__send__('litleOnlineRequest', root_attributes) do |doc|
-          yield(doc)
-        end
+        builder.__send__('litleOnlineRequest', root_attributes, &block)
         builder.doc.root.to_xml
       end
 

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

@@ -10,7 +10,7 @@ module ActiveMerchant
         if options[:pay_mode]
           post = new_post
           add_invoice(post, amount, options)
-          add_reference(post, *new_authorization)
+          add_reference(post, *new_authorization(options))
           add_payment_method(post, payment_method)
           add_customer_data(post, payment_method, options)
           add_3dsecure_id(post, options)
@@ -27,7 +27,7 @@ module ActiveMerchant
       def authorize(amount, payment_method, options = {})
         post = new_post
         add_invoice(post, amount, options)
-        add_reference(post, *new_authorization)
+        add_reference(post, *new_authorization(options))
         add_payment_method(post, payment_method)
         add_customer_data(post, payment_method, options)
         add_3dsecure_id(post, options)
@@ -264,9 +264,9 @@ module ActiveMerchant
         authorization.split('|')
       end
 
-      def new_authorization
+      def new_authorization(options)
         # Must be unique within a merchant id.
-        orderid = SecureRandom.uuid
+        orderid = options[:order_id] || SecureRandom.uuid
 
         # Must be unique within an order id.
         transactionid = '1'

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

@@ -79,8 +79,8 @@ module ActiveMerchant #:nodoc:
 
       private
 
-      def commit(action)
-        request = build_xml_request(action) { |doc| yield(doc) }
+      def commit(action, &block)
+        request = build_xml_request(action, &block)
         response = parse(ssl_post(url, request, 'Content-Type' => 'text/xml'))
 
         Response.new(

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

@@ -180,7 +180,7 @@ module ActiveMerchant #:nodoc:
 
       def commit(action, money, parameters)
         url = test? ? self.test_url : self.live_url
-        parameters[:transaction_amount] = amount(money) if money unless action == 'V'
+        parameters[:transaction_amount] = amount(money) if !(action == 'V') && money
 
         response =
           begin
@@ -189,11 +189,15 @@ module ActiveMerchant #:nodoc:
             { 'error_code' => '404', 'auth_response_text' => e.to_s }
           end
 
-        Response.new(success_from(response), message_from(response), response,
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
           authorization: authorization_from(response),
           test: test?,
           cvv_result: response['cvv2_result'],
-          avs_result: { code: response['avs_result'] })
+          avs_result: { code: response['avs_result'] }
+        )
       end
 
       def authorization_from(response)
@@ -220,8 +224,7 @@ module ActiveMerchant #:nodoc:
         post[:profile_key] = @options[:password]
         post[:transaction_type] = action if action
 
-        request = post.merge(parameters).map { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
-        request
+        post.merge(parameters).map { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
       end
     end
   end

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

@@ -290,19 +290,26 @@ module ActiveMerchant #:nodoc:
 
       def commit(action, request, v4 = false)
         begin
-          data = ssl_post(url(v4), request,
+          data = ssl_post(
+            url(v4),
+            request,
             'Content-Type' => 'text/xml; charset=utf-8',
-            'SOAPAction'   => soap_action(action, v4))
+            'SOAPAction'   => soap_action(action, v4)
+          )
           response = parse(action, data)
         rescue ActiveMerchant::ResponseError => e
           response = parse_error(e.response)
         end
 
-        Response.new(response[:success], response[:message], response,
+        Response.new(
+          response[:success],
+          response[:message],
+          response,
           test: test?,
           authorization: authorization_from(response),
           avs_result: { code: response['AVSResponse'] },
-          cvv_result: response['CVResponse'])
+          cvv_result: response['CVResponse']
+        )
       end
 
       def authorization_from(response)

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

@@ -261,19 +261,26 @@ module ActiveMerchant #:nodoc:
 
       def commit(action, request)
         begin
-          data = ssl_post(url, request,
+          data = ssl_post(
+            url,
+            request,
             'Content-Type' => 'text/xml; charset=utf-8',
-            'SOAPAction'   => soap_action(action))
+            'SOAPAction'   => soap_action(action)
+          )
           response = parse(action, data)
         rescue ActiveMerchant::ResponseError => e
           response = parse_error(e.response, action)
         end
 
-        Response.new(response[:success], response[:message], response,
+        Response.new(
+          response[:success],
+          response[:message],
+          response,
           test: test?,
           authorization: authorization_from(response),
           avs_result: { code: response['AvsResponse'] },
-          cvv_result: response['CvResponse'])
+          cvv_result: response['CvResponse']
+        )
       end
 
       def authorization_from(response)

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

@@ -32,6 +32,8 @@ module ActiveMerchant #:nodoc:
         add_payment_method(post, payment_method)
         add_recurring_flag(post, options)
         add_soft_descriptors(post, options)
+        add_three_ds(post, options)
+        post['storeID'] = options[:store_id] if options[:store_id]
         commit('processAuth', post)
       end
 
@@ -43,6 +45,8 @@ module ActiveMerchant #:nodoc:
         add_payment_method(post, payment_method)
         add_recurring_flag(post, options)
         add_soft_descriptors(post, options)
+        add_three_ds(post, options)
+        post['storeID'] = options[:store_id] if options[:store_id]
         commit('processCard', post)
       end
 
@@ -111,9 +115,9 @@ module ActiveMerchant #:nodoc:
         post['customerCity'] = address[:city]
         post['customerAddress'] = address[:address1]
         post['customerPostCode'] = address[:zip]
-        post['customerIP'] = address[:ip]
-        post['customerPhone'] = address[:phone]
-        post['customerEmail'] = address[:email]
+        post['customerIP'] = address[:ip] || options[:ip]
+        post['customerPhone'] = address[:phone] || address[:phone_number]
+        post['customerEmail'] = address[:email] || options[:email]
       end
 
       def add_order_id(post, options)
@@ -184,6 +188,18 @@ module ActiveMerchant #:nodoc:
         )
       end
 
+      def add_three_ds(post, options)
+        return unless three_d_secure = options[:three_d_secure]
+
+        post.merge!({
+          threeDSEci: three_d_secure[:eci],
+          threeDSXid: three_d_secure[:xid] || three_d_secure[:ds_transaction_id],
+          threeDSCavv: three_d_secure[:cavv],
+          threeDSStatus: three_d_secure[:authentication_response_status],
+          threeDSV2Version: three_d_secure[:version]
+        }.compact)
+      end
+
       def parse(body)
         xml = REXML::Document.new(body)
 

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

@@ -302,12 +302,16 @@ module ActiveMerchant #:nodoc:
         success = SUCCESS_CODES.include?(response[:cmd_status])
         message = success ? 'Success' : message_from(response)
 
-        Response.new(success, message, response,
+        Response.new(
+          success,
+          message,
+          response,
           test: test?,
           authorization: authorization_from(response),
           avs_result: { code: response[:avs_result] },
           cvv_result: response[:cvv_result],
-          error_code: success ? nil : STANDARD_ERROR_CODE_MAPPING[response[:dsix_return_code]])
+          error_code: success ? nil : STANDARD_ERROR_CODE_MAPPING[response[:dsix_return_code]]
+        )
       end
 
       def message_from(response)

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

@@ -175,12 +175,16 @@ module ActiveMerchant #:nodoc:
         #   (TESTMODE) Successful Sale
         test_mode = test? || message =~ /TESTMODE/
 
-        Response.new(success?(response), message, response,
+        Response.new(
+          success?(response),
+          message,
+          response,
           test: test_mode,
           authorization: response[:transaction_id],
           fraud_review: fraud_review?(response),
           avs_result: { code: response[:avs_result_code] },
-          cvv_result: response[:card_code])
+          cvv_result: response[:card_code]
+        )
       end
 
       def success?(response)
@@ -194,7 +198,7 @@ module ActiveMerchant #:nodoc:
       def parse(body)
         fields = split(body)
 
-        results = {
+        {
           response_code: fields[RESPONSE_CODE].to_i,
           response_reason_code: fields[RESPONSE_REASON_CODE],
           response_reason_text: fields[RESPONSE_REASON_TEXT],
@@ -202,7 +206,6 @@ module ActiveMerchant #:nodoc:
           transaction_id: fields[TRANSACTION_ID],
           card_code: fields[CARD_CODE_RESPONSE_CODE]
         }
-        results
       end
 
       def post_data(action, parameters = {})
@@ -218,8 +221,7 @@ module ActiveMerchant #:nodoc:
         post[:encap_char]     = '$'
         post[:solution_ID]    = application_id if application_id
 
-        request = post.merge(parameters).collect { |key, value| "x_#{key}=#{CGI.escape(value.to_s)}" }.join('&')
-        request
+        post.merge(parameters).collect { |key, value| "x_#{key}=#{CGI.escape(value.to_s)}" }.join('&')
       end
 
       def add_invoice(post, options)

data/lib/active_merchant/billing/gateways/migs/migs_codes.rb

@@ -71,6 +71,7 @@ module ActiveMerchant
 
       class CreditCardType
         attr_accessor :am_code, :migs_code, :migs_long_code, :name
+
         def initialize(am_code, migs_code, migs_long_code, name)
           @am_code        = am_code
           @migs_code      = migs_code

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

@@ -281,12 +281,16 @@ module ActiveMerchant #:nodoc:
         cvv_result_code = response[:CSCResultCode]
         cvv_result_code = 'P' if cvv_result_code == 'Unsupported'
 
-        Response.new(success?(response), response[:Message], response,
+        Response.new(
+          success?(response),
+          response[:Message],
+          response,
           test: test?,
           authorization: response[:TransactionNo],
           fraud_review: fraud_review?(response),
           avs_result: { code: avs_response_code },
-          cvv_result: cvv_result_code)
+          cvv_result: cvv_result_code
+        )
       end
 
       def success?(response)

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

@@ -7,6 +7,7 @@ module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class MitGateway < Gateway
       self.live_url = 'https://wpy.mitec.com.mx/ModuloUtilWS/activeCDP.htm'
+      self.test_url = 'https://scqa.mitec.com.mx/ModuloUtilWS/activeCDP.htm'
 
       self.supported_countries = ['MX']
       self.default_currency = 'MXN'
@@ -41,7 +42,7 @@ module ActiveMerchant #:nodoc:
         # original message
         full_data = unpacked[0].bytes.slice(16, unpacked[0].bytes.length)
         # Creates the engine
-        engine = OpenSSL::Cipher::AES128.new(:CBC)
+        engine = OpenSSL::Cipher.new('aes-128-cbc')
         # Set engine as decrypt mode
         engine.decrypt
         # Converts the key from hex to bytes
@@ -54,7 +55,7 @@ module ActiveMerchant #:nodoc:
 
       def encrypt(val, keyinhex)
         # Creates the engine motor
-        engine = OpenSSL::Cipher::AES128.new(:CBC)
+        engine = OpenSSL::Cipher.new('aes-128-cbc')
         # Set engine as encrypt mode
         engine.encrypt
         # Converts the key from hex to bytes
@@ -220,8 +221,12 @@ module ActiveMerchant #:nodoc:
         post[:name_client] = [payment.first_name, payment.last_name].join(' ')
       end
 
+      def url
+        test? ? test_url : live_url
+      end
+
       def commit(action, parameters)
-        raw_response = ssl_post(live_url, parameters, { 'Content-type' => 'text/plain' })
+        raw_response = ssl_post(url, parameters, { 'Content-type' => 'text/plain' })
         response = JSON.parse(decrypt(raw_response, @options[:key_session]))
 
         Response.new(