braintree 4.23.0 → 4.34.0

data/lib/braintree/xml/{libxml.rb → nokogiri.rb}

@@ -2,24 +2,24 @@
 # under the MIT license, copyright (c) 2005-2009 David Heinemeier Hansson
 module Braintree
   module Xml
-    module Libxml
-      LIB_XML_LIMIT = 30000000
+    module Nokogiri
+      NOKOGIRI_XML_LIMIT = 30000000
 
       def self.parse(xml_string)
-        old_keep_blanks_setting = ::LibXML::XML.default_keep_blanks
-        ::LibXML::XML.default_keep_blanks = false
-        root_node = LibXML::XML::Parser.string(xml_string.strip).parse.root
-        _node_to_hash(root_node)
-      ensure
-        ::LibXML::XML.default_keep_blanks = old_keep_blanks_setting
+        require "nokogiri" unless defined?(::Nokogiri)
+        doc = ::Nokogiri::XML(xml_string.strip)
+        _node_to_hash(doc.root)
       end
 
       def self._node_to_hash(node, hash = {})
-        if node.text?
-          raise ::LibXML::XML::Error if node.content.length >= LIB_XML_LIMIT
-          hash[CONTENT_ROOT] = node.content
+        sub_hash = node.text? ? hash : _build_sub_hash(hash, node.name)
+
+        if node.text? || (node.children.size == 1 && node.children.first.text?)
+          content = node.text? ? node.content : node.children.first.content
+          raise "Content too large" if content.length >= NOKOGIRI_XML_LIMIT
+          sub_hash[CONTENT_ROOT] = content
+          _attributes_to_hash(node, sub_hash) unless node.text?
         else
-          sub_hash = _build_sub_hash(hash, node.name)
           _attributes_to_hash(node, sub_hash)
           if _array?(node)
             _children_array_to_hash(node, sub_hash)
@@ -44,25 +44,27 @@ module Braintree
       end
 
       def self._children_to_hash(node, hash={})
-        node.each { |child| _node_to_hash(child, hash) }
+        node.children.each { |child| _node_to_hash(child, hash) unless child.text? && child.content.strip.empty? }
         _attributes_to_hash(node, hash)
         hash
       end
 
       def self._attributes_to_hash(node, hash={})
-        node.each_attr { |attr| hash[attr.name] = attr.value }
+        node.attributes.each { |name, attr| hash[name] = attr.value }
         hash
       end
 
       def self._children_array_to_hash(node, hash={})
-        hash[node.child.name] = node.map do |child|
+        first_child = node.children.find { |child| !child.text? }
+        hash[first_child.name] = node.children.select { |child| !child.text? }.map do |child|
           _children_to_hash(child, {})
         end
         hash
       end
 
       def self._array?(node)
-        node.child? && node.child.next? && node.child.name == node.child.next.name
+        non_text_children = node.children.select { |child| !child.text? }
+        non_text_children.size > 1 && non_text_children.first.name == non_text_children[1].name
       end
     end
   end

data/lib/braintree/xml/parser.rb

@@ -18,10 +18,10 @@ module Braintree
       end
 
       def self._determine_parser
-        # If LibXML is not available, we fall back to REXML
-        # This allows us to be compatible with JRuby, which LibXML does not support
-        if defined?(::LibXML::XML) && ::LibXML::XML.respond_to?(:default_keep_blanks=)
-          ::Braintree::Xml::Libxml
+        # If Nokogiri is available, use it for better performance
+        # Otherwise fall back to REXML for JRuby compatibility
+        if defined?(::Nokogiri)
+          ::Braintree::Xml::Nokogiri
         else
           ::Braintree::Xml::Rexml
         end

data/lib/braintree.rb

@@ -35,6 +35,9 @@ require "braintree/apple_pay_card"
 require "braintree/apple_pay_gateway"
 require "braintree/apple_pay_options"
 require "braintree/authorization_adjustment"
+require "braintree/bank_account_instant_verification_gateway"
+require "braintree/bank_account_instant_verification_jwt"
+require "braintree/bank_account_instant_verification_jwt_request"
 require "braintree/bin_data"
 require "braintree/client_token"
 require "braintree/client_token_gateway"
@@ -51,6 +54,7 @@ require "braintree/customer"
 require "braintree/customer_gateway"
 require "braintree/granted_payment_instrument_update"
 require "braintree/customer_search"
+require "braintree/customer_session_gateway"
 require "braintree/descriptor"
 require "braintree/digest"
 require "braintree/discount"
@@ -75,6 +79,20 @@ require "braintree/exchange_rate_quote_input"
 require "braintree/exchange_rate_quote_response"
 require "braintree/exchange_rate_quote_request"
 require "braintree/gateway"
+require "braintree/graphql/enums/recommendations"
+require "braintree/graphql/enums/recommended_payment_option"
+require "braintree/graphql/inputs/create_customer_session_input"
+require "braintree/graphql/inputs/customer_recommendations_input"
+require "braintree/graphql/inputs/customer_session_input"
+require "braintree/graphql/inputs/phone_input"
+require "braintree/graphql/inputs/update_customer_session_input"
+require "braintree/graphql/inputs/paypal_purchase_unit_input"
+require "braintree/graphql/inputs/paypal_payee_input"
+require "braintree/graphql/inputs/monetary_amount_input"
+require "braintree/graphql/types/customer_recommendations_payload"
+require "braintree/graphql/types/payment_options"
+require "braintree/graphql/types/payment_recommendations"
+require "braintree/graphql/unions/customer_recommendations"
 require "braintree/graphql_client"
 require "braintree/google_pay_card"
 require "braintree/local_payment_completed"
@@ -87,9 +105,6 @@ require "braintree/merchant"
 require "braintree/merchant_gateway"
 require "braintree/merchant_account"
 require "braintree/merchant_account_gateway"
-require "braintree/merchant_account/individual_details"
-require "braintree/merchant_account/business_details"
-require "braintree/merchant_account/funding_details"
 require "braintree/merchant_account/address_details"
 require "braintree/meta_checkout_card"
 require "braintree/meta_checkout_token"
@@ -106,6 +121,8 @@ require "braintree/payment_method_nonce_gateway"
 require "braintree/payment_method_parser"
 require "braintree/paypal_account"
 require "braintree/paypal_account_gateway"
+require "braintree/paypal_payment_resource"
+require "braintree/paypal_payment_resource_gateway"
 require "braintree/plan"
 require "braintree/plan_gateway"
 require "braintree/processor_response_types"
@@ -186,6 +203,6 @@ require "braintree/webhook_testing"
 require "braintree/webhook_testing_gateway"
 require "braintree/xml"
 require "braintree/xml/generator"
-require "braintree/xml/libxml"
+require "braintree/xml/nokogiri"
 require "braintree/xml/rexml"
 require "braintree/xml/parser"

data/spec/integration/braintree/advanced_search_spec.rb

@@ -33,7 +33,8 @@ describe Braintree::AdvancedSearch do
       expect(collection).not_to include(subscription2)
     end
 
-    it "is_not" do
+    # we are temporarily skipping this test until we have a more stable CI env
+    xit "is_not" do
       id = rand(36**8).to_s(36)
       subscription1 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
@@ -80,7 +81,8 @@ describe Braintree::AdvancedSearch do
       expect(collection).not_to include(subscription2)
     end
 
-    it "ends_with" do
+    # we are temporarily skipping this test until we have a more stable CI env
+    xit "ends_with" do
       id = rand(36**8).to_s(36)
       subscription1 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
@@ -175,7 +177,8 @@ describe Braintree::AdvancedSearch do
         expect(collection).not_to include(subscription2)
       end
 
-      it "returns only matching results given an argument list" do
+      # ignore until more stable CI
+      xit "returns only matching results given an argument list" do
         subscription1 = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
@@ -262,7 +265,7 @@ describe Braintree::AdvancedSearch do
 
   context "multiple_value_or_text_field" do
     describe "in" do
-      it "works for the in operator" do
+      xit "works for the in operator(temporarily disabling until more stable CI)" do
         Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],

data/spec/integration/braintree/apple_pay_spec.rb

@@ -2,20 +2,19 @@ require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
 
 describe Braintree::ApplePayGateway do
   before(:each) do
-    gateway = Braintree::Gateway.new(
+    oauth_gateway = Braintree::Gateway.new(
       :client_id => "client_id$#{Braintree::Configuration.environment}$integration_client_id",
       :client_secret => "client_secret$#{Braintree::Configuration.environment}$integration_client_secret",
       :logger => Logger.new("/dev/null"),
     )
 
-    result = gateway.merchant.create(
-      :email => "name@email.com",
-      :country_code_alpha3 => "GBR",
-      :payment_methods => ["credit_card", "paypal"],
-    )
+    access_token = Braintree::OAuthTestHelper.create_token(oauth_gateway, {
+      :merchant_public_id => "integration_merchant_id",
+      :scope => "read_write"
+    }).credentials.access_token
 
     @gateway = Braintree::Gateway.new(
-      :access_token => result.credentials.access_token,
+      :access_token => access_token,
       :logger => Logger.new("/dev/null"),
     )
   end

data/spec/integration/braintree/bank_account_instant_verification_spec.rb

@@ -0,0 +1,191 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::BankAccountInstantVerificationGateway do
+  before do
+    @gateway = Braintree::Gateway.new(
+      :environment => :development,
+      :merchant_id => "integration2_merchant_id",
+      :public_key => "integration2_public_key",
+      :private_key => "integration2_private_key",
+    )
+
+    @us_bank_gateway = Braintree::Gateway.new(
+      :environment => :development,
+      :merchant_id => "integration_merchant_id",
+      :public_key => "integration_public_key",
+      :private_key => "integration_private_key",
+    )
+  end
+
+  describe "create_jwt" do
+    it "creates a jwt with valid request" do
+      request = Braintree::BankAccountInstantVerificationJwtRequest.new(
+        :business_name => "15Ladders",
+        :return_url => "https://example.com/success",
+        :cancel_url => "https://example.com/cancel",
+      )
+
+      result = @gateway.bank_account_instant_verification.create_jwt(request)
+
+      unless result.success?
+        puts "DEBUG: Result failed!"
+        puts "DEBUG: Errors: #{result.errors.inspect}" if result.respond_to?(:errors)
+      end
+
+      expect(result.success?).to eq(true)
+      expect(result.bank_account_instant_verification_jwt).to have_attributes(
+        jwt: a_string_matching(/.+/),
+      )
+    end
+
+    it "fails with invalid business name" do
+      request = Braintree::BankAccountInstantVerificationJwtRequest.new(
+        :business_name => "", # Empty business name should cause validation error
+        :return_url => "https://example.com/return",
+        :cancel_url => "https://example.com/cancel",
+      )
+
+      result = @gateway.bank_account_instant_verification.create_jwt(request)
+
+      expect(result.success?).to eq(false)
+      expect(result.errors).not_to be_nil
+    end
+
+    it "fails with invalid URLs" do
+      request = Braintree::BankAccountInstantVerificationJwtRequest.new(
+        :business_name => "15Ladders",
+        :return_url => "not-a-valid-url",
+        :cancel_url => "also-not-valid",
+      )
+
+      result = @us_bank_gateway.bank_account_instant_verification.create_jwt(request)
+
+      expect(result.success?).to eq(false)
+      expect(result.errors).not_to be_nil
+    end
+  end
+
+  describe "charge US bank with ACH mandate" do
+    it "creates transaction directly with nonce and provides ACH mandate at transaction time (instant verification)" do
+      nonce = generate_us_bank_account_nonce_via_open_banking
+
+      mandate_accepted_at = Time.now - 300 # 5 minutes ago
+
+      # Create transaction directly with nonce and provide ACH mandate at transaction time (instant verification)
+      transaction_request = {
+        :amount => "12.34",
+        :payment_method_nonce => nonce,
+        :merchant_account_id => SpecHelper::UsBankMerchantAccountId, # could it be?
+        :us_bank_account => {
+          :ach_mandate_text => "I authorize this transaction and future debits",
+          :ach_mandate_accepted_at => mandate_accepted_at
+        },
+        :options => {
+          :submit_for_settlement => true
+        }
+      }
+
+      transaction_result = @us_bank_gateway.transaction.sale(transaction_request)
+
+      expect(transaction_result.success?).to eq(true), "Expected transaction success but got failure with validation errors (see console output)"
+      transaction = transaction_result.transaction
+
+      expected_transaction = {
+        id: a_string_matching(/.+/),
+        amount: BigDecimal("12.34"),
+        us_bank_account_details: have_attributes(
+          ach_mandate: have_attributes(
+            text: "I authorize this transaction and future debits",
+            accepted_at: be_a(Time),
+          ),
+          account_holder_name: "Dan Schulman",
+          last_4: "1234",
+          routing_number: "021000021",
+          account_type: "checking",
+        )
+      }
+
+      expect(transaction).to have_attributes(expected_transaction)
+    end
+  end
+
+  describe "Open Finance flow with INSTANT_VERIFICATION_ACCOUNT_VALIDATION" do
+    it "tokenizes bank account via Open Finance API, vaults with and charges" do
+
+      nonce = generate_us_bank_account_nonce_via_open_banking
+
+      customer_result = @us_bank_gateway.customer.create({})
+      expect(customer_result.success?).to eq(true)
+      customer = customer_result.customer
+
+      mandate_accepted_at = Time.now - 300
+
+      payment_method_request = {
+        :customer_id => customer.id,
+        :payment_method_nonce => nonce,
+        :us_bank_account => {
+          :ach_mandate_text => "I authorize this transaction and future debits",
+          :ach_mandate_accepted_at => mandate_accepted_at
+        },
+        :options => {
+          :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+          :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::InstantVerificationAccountValidation
+        }
+      }
+
+      payment_method_result = @us_bank_gateway.payment_method.create(payment_method_request)
+      expect(payment_method_result.success?).to eq(true), "Expected payment method creation success but got failure with validation errors"
+
+      us_bank_account = payment_method_result.payment_method
+
+      expected_us_bank_account = {
+        verifications: a_collection_containing_exactly(
+          have_attributes(
+            verification_method: Braintree::UsBankAccountVerification::VerificationMethod::InstantVerificationAccountValidation,
+            status: "verified",
+          ),
+        ),
+        ach_mandate: have_attributes(
+          text: "I authorize this transaction and future debits",
+          accepted_at: be_a(Time),
+        )
+      }
+
+      expect(us_bank_account).to have_attributes(expected_us_bank_account)
+
+      verification = us_bank_account.verifications.first
+      expect(verification.verification_method).to eq(Braintree::UsBankAccountVerification::VerificationMethod::InstantVerificationAccountValidation)
+
+      transaction_request = {
+        :amount => "12.34",
+        :payment_method_token => us_bank_account.token,
+        :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+        :options => {
+          :submit_for_settlement => true
+        }
+      }
+
+      transaction_result = @us_bank_gateway.transaction.sale(transaction_request)
+      expect(transaction_result.success?).to eq(true), "Expected transaction success but got failure"
+      transaction = transaction_result.transaction
+
+      expected_transaction = {
+        id: a_string_matching(/.+/),
+        amount: BigDecimal("12.34"),
+        us_bank_account_details: have_attributes(
+          token: us_bank_account.token,
+          ach_mandate: have_attributes(
+            text: "I authorize this transaction and future debits",
+            accepted_at: be_a(Time),
+          ),
+          last_4: "1234",
+          routing_number: "021000021",
+          account_type: "checking",
+        )
+      }
+
+      expect(transaction).to have_attributes(expected_transaction)
+    end
+  end
+end

data/spec/integration/braintree/client_api/spec_helper.rb

@@ -147,6 +147,87 @@ def generate_invalid_us_bank_account_nonce
   nonce + "_xxx"
 end
 
+def generate_us_bank_account_nonce_via_open_banking
+
+  config = Braintree::Configuration.new(
+    :environment => :development,
+    :merchant_id => "integration_merchant_id",
+    :public_key => "integration_public_key",
+    :private_key => "integration_private_key",
+  )
+
+  request_body = {
+    :account_details => {
+      :account_number => "567891234",
+      :account_type => "CHECKING",
+      :classification => "PERSONAL",
+      :tokenized_account => true,
+      :last_4 => "1234"
+    },
+    :institution_details => {
+      :bank_id => {
+        :bank_code => "021000021",
+        :country_code => "US"
+      }
+    },
+    :account_holders => [
+      {
+        :ownership => "PRIMARY",
+        :full_name => {
+          :name => "Dan Schulman"
+        },
+        :name => {
+          :given_name => "Dan",
+          :surname => "Schulman",
+          :full_name => "Dan Schulman"
+        }
+      }
+    ]
+  }
+
+  graphql_base_url = config.graphql_base_url
+  atmosphere_base_url = graphql_base_url.gsub("/graphql", "")
+  url = "#{atmosphere_base_url}/v1/open-finance/tokenize-bank-account-details"
+
+  uri = URI.parse(url)
+  connection = Net::HTTP.new(uri.host, uri.port)
+
+  if uri.scheme == "https"
+    connection.use_ssl = true
+    connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    connection.ca_file = config.ca_file if config.ca_file
+  end
+
+  response = connection.start do |http|
+    request = Net::HTTP::Post.new(uri.path)
+    request["Content-Type"] = "application/json"
+    request["Accept"] = "application/json"
+    request["Braintree-Version"] = "2019-01-01"
+    request["User-Agent"] = "Braintree Ruby Library #{Braintree::Version::String}"
+    request["X-ApiVersion"] = config.api_version
+
+    # Basic auth like Node.js
+    auth_string = "#{config.public_key}:#{config.private_key}"
+    request["Authorization"] = "Basic #{Base64.strict_encode64(auth_string)}"
+
+    request.body = request_body.to_json
+
+    http.request(request)
+  end
+
+  if response.code.to_i != 200
+    raise "HTTP #{response.code}: #{response.body}"
+  end
+
+  result = JSON.parse(response.body)
+
+  unless result["tenant_token"]
+    raise "Open Banking tokenization failed: #{result.inspect}"
+  end
+
+  result["tenant_token"]
+end
+
 def _cosmos_post(token, url, payload)
   uri = URI::parse(url)
   connection = Net::HTTP.new(uri.host, uri.port)

data/spec/integration/braintree/credit_card_spec.rb

@@ -449,6 +449,66 @@ describe Braintree::CreditCard do
         expect(credit_card.prepaid).to eq(Braintree::CreditCard::Prepaid::Yes)
       end
 
+      it "sets the prepaid reloadable field if the card is prepaid reloadable" do
+        customer = Braintree::Customer.create!
+        result = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::PrepaidReloadable,
+          :expiration_date => "05/2014",
+          :options => {:verify_card => true},
+        )
+        credit_card = result.credit_card
+        expect(credit_card.prepaid_reloadable).to eq(Braintree::CreditCard::PrepaidReloadable::Yes)
+      end
+
+      it "sets the business field if the card is business" do
+        customer = Braintree::Customer.create!
+        result = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Business,
+          :expiration_date => "05/2014",
+          :options => {:verify_card => true},
+        )
+        credit_card = result.credit_card
+        expect(credit_card.business).to eq(Braintree::CreditCard::Business::Yes)
+      end
+
+      it "sets the consumer field if the card is consumer" do
+        customer = Braintree::Customer.create!
+        result = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Consumer,
+          :expiration_date => "05/2014",
+          :options => {:verify_card => true},
+        )
+        credit_card = result.credit_card
+        expect(credit_card.consumer).to eq(Braintree::CreditCard::Consumer::Yes)
+      end
+
+      it "sets the corporate field if the card is corporate" do
+        customer = Braintree::Customer.create!
+        result = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Corporate,
+          :expiration_date => "05/2014",
+          :options => {:verify_card => true},
+        )
+        credit_card = result.credit_card
+        expect(credit_card.corporate).to eq(Braintree::CreditCard::Corporate::Yes)
+      end
+
+      it "sets the purchase field if the card is purchase" do
+        customer = Braintree::Customer.create!
+        result = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Purchase,
+          :expiration_date => "05/2014",
+          :options => {:verify_card => true},
+        )
+        credit_card = result.credit_card
+        expect(credit_card.purchase).to eq(Braintree::CreditCard::Purchase::Yes)
+      end
+
       it "sets the healthcare field if the card is healthcare" do
         customer = Braintree::Customer.create!
         result = Braintree::CreditCard.create(
@@ -1203,7 +1263,8 @@ describe Braintree::CreditCard do
   end
 
   describe "self.expiring_between" do
-    it "finds payment methods expiring between the given dates" do
+    #Disabling this test until we have a more stable CI
+    xit "finds payment methods expiring between the given dates" do
       next_year = Time.now.year + 1
       collection = Braintree::CreditCard.expiring_between(Time.mktime(next_year, 1), Time.mktime(next_year, 12))
       expect(collection.maximum_size).to be > 0
@@ -1437,4 +1498,57 @@ describe Braintree::CreditCard do
       expect(credit_card_vaulted.is_network_tokenized?).to eq(false)
     end
   end
+
+  describe "account information inquiry" do
+    it "includes ani response when account information inquiry is sent in options" do
+      customer = Braintree::Customer.create!
+      result = Braintree::CreditCard.create(
+        :cardholder_name => "John Doe",
+        :customer_id => customer.id,
+        :cvv => "123",
+        :number => Braintree::Test::CreditCardNumbers::Visa,
+        :expiration_date => "05/2027",
+        :billing_address => {
+          :first_name => "John",
+          :last_name => "Doe",
+        },
+        :options => {
+          :account_information_inquiry => "send_data",
+          :verify_card => true,
+        },
+      )
+
+      expect(result).to be_success
+      verification = result.credit_card.verification
+      expect(verification.ani_first_name_response_code).not_to be_nil
+      expect(verification.ani_last_name_response_code).not_to be_nil
+    end
+
+    it "includes ani response  after updating the options with account information inquiry" do
+      customer = Braintree::Customer.create!
+      credit_card = Braintree::CreditCard.create!(
+        :cardholder_name => "Original Holder",
+        :customer_id => customer.id,
+        :cvv => "123",
+        :number => Braintree::Test::CreditCardNumbers::Visa,
+        :expiration_date => "05/2027",
+      )
+      updated_result = Braintree::CreditCard.update(credit_card.token,
+        :options => {
+          :verify_card => true,
+          :account_information_inquiry => "send_data",
+        },
+      )
+
+      expect(updated_result).to be_success
+      verification = updated_result.credit_card.verification
+      expect(verification.ani_first_name_response_code).not_to be_nil
+      expect(verification.ani_last_name_response_code).not_to be_nil
+    end
+  end
 end
+
+
+
+
+