braintree 4.33.0 → 4.35.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e524f55d0d9990e6d2c25d6dbd81b3d75833ef145a624c70af52119d2b71fd8
-  data.tar.gz: c060e46e74b749cd934e7eecef42f4d783e6e8252ed59aff41acf574379141a3
+  metadata.gz: b265c2399fc0ef51a35bfdd1b804ec05e1173b9f1ee04a8fd47b29ee7494062c
+  data.tar.gz: b52c492b7b84c343a287d60d27b63f9813aa7a5c099cfc52d91a7590285d739f
 SHA512:
-  metadata.gz: 2796040657fc77358e616b12dea6b8e1e9ebb1b06bd0d0d284b7ee2cb14f2e12d34e5570ed9d512b07293ef5605751ba2116a637077b0b19f0a2d6fd11704ada
-  data.tar.gz: 31ce1b5335dd36150b8f2dc46df425e17ea4e10bf2e8d0a6b44d2d0f72732c72e3d3b6f9f0a9362de56ded2ca70037a707210f72cff45955947407a8bc61273a
+  metadata.gz: 964368649d781437f2f2c5bdbdc75e953c577ab637baa9e5df9c6498c3e70ac3da83e1583540451505fedef5688e49373b3831ff01c2c18f15a229643e77c15b
+  data.tar.gz: ca2a9f488eca05e47ec7bf5b52e27db811bcffbb80c972a5a313522bfce5373a245de8c0a202319babfaebe9655f73960f1f1d1d5b57822b4694c0003aa74789

data/lib/braintree/credit_card_verification_gateway.rb

@@ -18,7 +18,8 @@ module Braintree
       search = CreditCardVerificationSearch.new
       block.call(search) if block
 
-      response = @config.http.post("#{@config.base_merchant_path}/verifications/advanced_search_ids", {:search => search.to_hash})
+      search_params = search.to_hash.merge({:verification_type => ["credit_card"]})
+      response = @config.http.post("#{@config.base_merchant_path}/verifications/advanced_search_ids", {:search => search_params})
       ResourceCollection.new(response) { |ids| _fetch_verifications(search, ids) }
     end
 
@@ -39,7 +40,8 @@ module Braintree
 
     def _fetch_verifications(search, ids)
       search.ids.in ids
-      response = @config.http.post("#{@config.base_merchant_path}/verifications/advanced_search", {:search => search.to_hash})
+      search_params = search.to_hash.merge({:verification_type => ["credit_card"]})
+      response = @config.http.post("#{@config.base_merchant_path}/verifications/advanced_search", {:search => search_params})
       attributes = response[:credit_card_verifications]
       Util.extract_attribute_as_array(attributes, :verification).map { |attrs| CreditCardVerification._new(attrs) }
     end

data/lib/braintree/customer.rb

@@ -90,7 +90,7 @@ module Braintree
       @google_pay_cards = (@google_pay_cards || []).map { |pm| GooglePayCard._new gateway, pm }
       @venmo_accounts = (@venmo_accounts || []).map { |pm| VenmoAccount._new gateway, pm }
       @us_bank_accounts = (@us_bank_accounts || []).map { |pm| UsBankAccount._new gateway, pm }
-      @visa_checkout_cards = (@visa_checkout_cards|| []).map { |pm| VisaCheckoutCard._new gateway, pm }
+      @visa_checkout_cards = (@visa_checkout_cards|| []).map { |pm| VisaCheckoutCard._new gateway, pm } # Deprecated
       @sepa_direct_debit_accounts = (@sepa_debit_accounts || []).map { |pm| SepaDirectDebitAccount._new gateway, pm }
       @samsung_pay_cards = (@samsung_pay_cards|| []).map { |pm| SamsungPayCard._new gateway, pm } # Deprecated
       @addresses = (@addresses || []).map { |addr| Address._new gateway, addr }

data/lib/braintree/payment_instrument_type.rb

@@ -13,6 +13,7 @@ module Braintree
     SepaDirectDebitAccount = "sepa_debit_account"
     UsBankAccount = "us_bank_account"
     VenmoAccount = "venmo_account"
+    # NEXT_MAJOR_VERSION remove VisaCheckoutCard
     VisaCheckoutCard = "visa_checkout_card"
   end
 end

data/lib/braintree/payment_method_parser.rb

@@ -15,6 +15,7 @@ module Braintree
       elsif attributes[:venmo_account]
         VenmoAccount._new(gateway, attributes[:venmo_account])
       elsif attributes[:visa_checkout_card]
+        warn "[DEPRECATED] VisaCheckoutCard is no longer a supported payment method type"
         VisaCheckoutCard._new(gateway, attributes[:visa_checkout_card])
       elsif attributes[:samsung_pay_card]
         warn "[DEPRECATED] SamsungPayCard is no longer a supported payment method type"

data/lib/braintree/test/nonce.rb

@@ -65,6 +65,7 @@ module Braintree
       PayPalFuturePaymentRefreshToken = "fake-paypal-future-refresh-token-nonce"
       GatewayRejectedFraud = "fake-gateway-rejected-fraud-nonce"
       GatewayRejectedRiskThresholds = "fake-gateway-rejected-risk-thresholds-nonce"
+      # NEXT_MAJOR_VERSION VisaCheckoutCard is deprecated, remove associated nonces
       VisaCheckoutAmEx = "fake-visa-checkout-amex-nonce"
       VisaCheckoutDiscover = "fake-visa-checkout-discover-nonce"
       VisaCheckoutMasterCard = "fake-visa-checkout-mastercard-nonce"

data/lib/braintree/test/transaction_amounts.rb

@@ -3,6 +3,7 @@ module Braintree
     # NEXT_MAJOR_VERSION are these even being used anymore? Can we remove this class??
     module TransactionAmounts
       Authorize = "1000.00"
+      PartiallyAuthorized = "1004.00"
       Decline = "2000.00"
       HardDecline = "2015.00"
       Fail = "3000.00"

data/lib/braintree/transaction/visa_checkout_card_details.rb

@@ -1,5 +1,7 @@
 module Braintree
   class Transaction
+    # DEPRECATED: Visa Checkout is no longer supported for creating new transactions.
+    # This class is retained for search functionality and historical transaction data only.
     class VisaCheckoutCardDetails
       include BaseModule
 

data/lib/braintree/transaction.rb

@@ -86,6 +86,7 @@ module Braintree
     attr_reader :ach_reject_reason
     attr_reader :ach_return_code
     attr_reader :ach_return_responses
+    attr_reader :ach_type
     attr_reader :acquirer_reference_number
     attr_reader :add_ons
     attr_reader :additional_processor_response          # The raw response from the processor.
@@ -133,6 +134,7 @@ module Braintree
     attr_reader :order_id
     attr_reader :packages
     attr_reader :partial_settlement_transaction_ids
+    attr_reader :partially_authorized
     attr_reader :payment_instrument_type
     attr_reader :payment_receipt
     attr_reader :paypal_details
@@ -150,6 +152,7 @@ module Braintree
     attr_reader :refund_ids
     attr_reader :refunded_installments
     attr_reader :refunded_transaction_id
+    attr_reader :requested_ach_type
     attr_reader :retried
     attr_reader :retried_transaction_id                 # the primary/parent transaction id of any retried transaction
     attr_reader :retrieval_reference_number
@@ -310,7 +313,7 @@ module Braintree
       @payment_receipt = PaymentReceipt.new(attributes[:payment_receipt]) if attributes[:payment_receipt]
       @paypal_details = PayPalDetails.new(@paypal)
       @paypal_here_details = PayPalHereDetails.new(@paypal_here)
-      @samsung_pay_card_details = SamsungPayCardDetails.new(attributes[:samsung_pay_card]) #Deprecated
+      @samsung_pay_card_details = SamsungPayCardDetails.new(attributes[:samsung_pay_card]) # Deprecated
       @sca_exemption_requested = attributes[:sca_exemption_requested]
       @sepa_direct_debit_account_details = SepaDirectDebitAccountDetails.new(@sepa_debit_account_detail)
       @service_fee_amount = Util.to_big_decimal(service_fee_amount)
@@ -318,9 +321,10 @@ module Braintree
       @shipping_details = AddressDetails.new(@shipping)
       @status_history = attributes[:status_history] ? attributes[:status_history].map { |s| StatusDetails.new(s) } : []
       @subscription_details = SubscriptionDetails.new(@subscription)
+      @partially_authorized = %w[1004].include?(processor_response_code)
       @tax_amount = Util.to_big_decimal(tax_amount)
       @venmo_account_details = VenmoAccountDetails.new(@venmo_account)
-      @visa_checkout_card_details = VisaCheckoutCardDetails.new(attributes[:visa_checkout_card])
+      @visa_checkout_card_details = VisaCheckoutCardDetails.new(attributes[:visa_checkout_card]) # Deprecated
 
       @facilitated_details = FacilitatedDetails.new(attributes[:facilitated_details]) if attributes[:facilitated_details]
       @facilitator_details = FacilitatorDetails.new(attributes[:facilitator_details]) if attributes[:facilitator_details]

data/lib/braintree/transaction_gateway.rb

@@ -194,7 +194,7 @@ module Braintree
     # three_d_secure_token has been deprecated in favor of three_d_secure_authentication_id
     def self._create_signature
       [
-        :amount, :billing_address_id, :channel, :currency_iso_code, :customer_id, :device_data,
+        :accept_partial_authorization, :amount, :billing_address_id, :channel, :currency_iso_code, :customer_id, :device_data,
         :discount_amount, :exchange_rate_quote_id, :foreign_retailer,
         :merchant_account_id, :order_id, :payment_method_nonce, :payment_method_token, :processing_merchant_category_code,
         :product_sku, :purchase_order_number, :service_fee_amount, :shared_billing_address_id,
@@ -250,6 +250,7 @@ module Braintree
           :store_shipping_address_in_vault,
           :submit_for_settlement,
           {:three_d_secure => [:required]},
+          {:us_bank_account => [:ach_type]},
           {:venmo => [:profile_id]},
           :venmo_sdk_session, # Deprecated
         ]
@@ -285,18 +286,21 @@ module Braintree
             :type,
             {
               :sender => [
+                :account_reference_number,
+                :date_of_birth,
                 :first_name,
                 :last_name,
-                :account_reference_number,
+                :middle_name,
                 :tax_id,
                 {:address => AddressGateway._address_attributes}
               ]
             },
             {
               :receiver => [
+                :account_reference_number,
                 :first_name,
                 :last_name,
-                :account_reference_number,
+                :middle_name,
                 :tax_id,
                 {:address => AddressGateway._address_attributes}
               ]

data/lib/braintree/version.rb

@@ -1,7 +1,7 @@
 module Braintree
   module Version
     Major = 4
-    Minor = 33
+    Minor = 35
     Tiny = 0
 
     String = "#{Major}.#{Minor}.#{Tiny}"

data/lib/braintree/visa_checkout_card.rb

@@ -1,4 +1,6 @@
 module Braintree
+  # DEPRECATED: Visa Checkout is no longer supported for creating new transactions.
+  # This class is retained for search functionality and historical transaction data only.
   class VisaCheckoutCard
     include BaseModule
     include Braintree::Util::TokenEquality

data/lib/braintree/xml/nokogiri.rb

@@ -12,12 +12,14 @@ module Braintree
       end
 
       def self._node_to_hash(node, hash = {})
+        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
-          hash[CONTENT_ROOT] = content
+          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)
@@ -66,4 +68,4 @@ module Braintree
       end
     end
   end
-end
+end

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/customer_spec.rb

@@ -1979,20 +1979,4 @@ describe Braintree::Customer do
     end
   end
 
-  it "returns bin fields from VisaCheckoutCard" do
-    result = Braintree::Customer.create(
-      :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutVisa,
-    )
-    expect(result.success?).to eq(true)
-
-    found_customer = Braintree::Customer.find(result.customer.id)
-    expect(found_customer.visa_checkout_cards).not_to be_nil
-    visa_checkout_card = found_customer.visa_checkout_cards.first
-    expect(visa_checkout_card).to be_a Braintree::VisaCheckoutCard
-    expect(visa_checkout_card.business).not_to be_nil
-    expect(visa_checkout_card.consumer).not_to be_nil
-    expect(visa_checkout_card.corporate).not_to be_nil
-    expect(visa_checkout_card.prepaid_reloadable).not_to be_nil
-    expect(visa_checkout_card.purchase).not_to be_nil
-  end
 end

data/spec/integration/braintree/merchant_account_spec.rb

@@ -95,10 +95,14 @@ describe Braintree::MerchantAccount do
         :logger => Logger.new("/dev/null"),
       )
 
-      result = gateway.merchant.create(
-        :email => "name@email.com",
-        :country_code_alpha3 => "GBR",
-        :payment_methods => ["credit_card", "paypal"],
+      code = Braintree::OAuthTestHelper.create_grant(gateway, {
+        :merchant_public_id => "integration_merchant_id",
+        :scope => "read_write"
+      })
+
+      result = gateway.oauth.create_token_from_code(
+        :code => code,
+        :scope => "read_write",
       )
 
       gateway = Braintree::Gateway.new(
@@ -108,10 +112,8 @@ describe Braintree::MerchantAccount do
 
       result = gateway.merchant_account.all
       expect(result).to be_success
-      expect(result.merchant_accounts.count).to eq(1)
-      expect(result.merchant_accounts.first.currency_iso_code).to eq("GBP")
+      expect(result.merchant_accounts.count).to be > 0
       expect(result.merchant_accounts.first.status).to eq("active")
-      expect(result.merchant_accounts.first.default).to eq(true)
     end
 
     it "returns all merchant accounts for read_only scoped grants" do
@@ -144,7 +146,7 @@ describe Braintree::MerchantAccount do
 
   describe "create_for_currency" do
     it "creates a new merchant account for currency" do
-      result = SpecHelper::create_merchant
+      result = SpecHelper::get_merchant
       expect(result).to be_success
 
       gateway = Braintree::Gateway.new(
@@ -153,14 +155,14 @@ describe Braintree::MerchantAccount do
       )
 
       result = gateway.merchant_account.create_for_currency(
-        :currency => "JPY",
+        :currency => "AUD",
       )
       expect(result).to be_success
-      expect(result.merchant_account.currency_iso_code).to eq("JPY")
+      expect(result.merchant_account.currency_iso_code).to eq("AUD")
     end
 
     it "returns error if a merchant account already exists for that currency" do
-      result = SpecHelper::create_merchant
+      result = SpecHelper::get_merchant
       expect(result).to be_success
 
       gateway = Braintree::Gateway.new(
@@ -169,12 +171,12 @@ describe Braintree::MerchantAccount do
       )
 
       result = gateway.merchant_account.create_for_currency(
-        :currency => "USD",
+        :currency => "CAD",
       )
       expect(result).to be_success
 
       result = gateway.merchant_account.create_for_currency(
-        :currency => "USD",
+        :currency => "CAD",
       )
       expect(result).not_to be_success
 
@@ -183,7 +185,7 @@ describe Braintree::MerchantAccount do
     end
 
     it "returns error if no currency is provided" do
-      result = SpecHelper::create_merchant
+      result = SpecHelper::get_merchant
       expect(result).to be_success
 
       gateway = Braintree::Gateway.new(
@@ -207,7 +209,7 @@ describe Braintree::MerchantAccount do
     end
 
     it "returns error if a currency is not supported" do
-      result = SpecHelper::create_merchant
+      result = SpecHelper::get_merchant
       expect(result).to be_success
 
       gateway = Braintree::Gateway.new(
@@ -225,7 +227,7 @@ describe Braintree::MerchantAccount do
     end
 
     it "returns error if id is passed and already taken" do
-      result = SpecHelper::create_merchant
+      result = SpecHelper::get_merchant
       expect(result).to be_success
 
       gateway = Braintree::Gateway.new(
@@ -235,7 +237,7 @@ describe Braintree::MerchantAccount do
 
       merchant = result.merchant
       result = gateway.merchant_account.create_for_currency(
-        :currency => "USD",
+        :currency => "GBP",
         :id => merchant.merchant_accounts.first.id,
       )
       expect(result).not_to be_success

data/spec/integration/braintree/merchant_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
 
 describe Braintree::MerchantGateway do
   describe "create" do
-    it "creates a merchant" do
+    xit "creates a merchant" do
       gateway = Braintree::Gateway.new(
         :client_id => "client_id$#{Braintree::Configuration.environment}$integration_client_id",
         :client_secret => "client_secret$#{Braintree::Configuration.environment}$integration_client_secret",
@@ -59,7 +59,7 @@ describe Braintree::MerchantGateway do
         Braintree::Configuration.merchant_id = old_merchant_id_value
       end
 
-      it "allows using a merchant_id passed in through Gateway" do
+      xit "allows using a merchant_id passed in through Gateway" do
         Braintree::Configuration.merchant_id = nil
 
         gateway = Braintree::Gateway.new(
@@ -87,7 +87,7 @@ describe Braintree::MerchantGateway do
         )
       end
 
-      it "creates an EU multi currency merchant for paypal and credit_card" do
+      xit "creates an EU multi currency merchant for paypal and credit_card" do
         result = @gateway.merchant.create(
           :email => "name@email.com",
           :country_code_alpha3 => "GBR",
@@ -123,7 +123,7 @@ describe Braintree::MerchantGateway do
       end
 
 
-      it "creates a paypal-only merchant that accepts multiple currencies" do
+      xit "creates a paypal-only merchant that accepts multiple currencies" do
         result = @gateway.merchant.create(
           :email => "name@email.com",
           :country_code_alpha3 => "GBR",

data/spec/integration/braintree/payment_method_spec.rb

@@ -207,9 +207,9 @@ describe Braintree::PaymentMethod do
       expect(google_pay_card.image_url).to match(/android_pay/)
       expect(google_pay_card.is_network_tokenized?).to eq(true)
       expect(google_pay_card.source_card_type).to eq(Braintree::CreditCard::CardType::MasterCard)
-      expect(google_pay_card.source_card_last_4).to eq("4444")
+      expect(google_pay_card.source_card_last_4).to eq("0005")
       expect(google_pay_card.google_transaction_id).to eq("google_transaction_id")
-      expect(google_pay_card.source_description).to eq("MasterCard 4444")
+      expect(google_pay_card.source_description).to eq("MasterCard 0005")
       expect(google_pay_card.customer_id).to eq(customer.id)
       expect(google_pay_card.commercial).not_to be_nil
       expect(google_pay_card.country_of_issuance).not_to be_nil
@@ -1337,9 +1337,9 @@ describe Braintree::PaymentMethod do
         expect(google_pay_card.image_url).to match(/android_pay/)
         expect(google_pay_card.is_network_tokenized?).to eq(true)
         expect(google_pay_card.source_card_type).to eq(Braintree::CreditCard::CardType::MasterCard)
-        expect(google_pay_card.source_card_last_4).to eq("4444")
+        expect(google_pay_card.source_card_last_4).to eq("0005")
         expect(google_pay_card.google_transaction_id).to eq("google_transaction_id")
-        expect(google_pay_card.source_description).to eq("MasterCard 4444")
+        expect(google_pay_card.source_description).to eq("MasterCard 0005")
         expect(google_pay_card.customer_id).to eq(customer.id)
       end
     end

data/spec/integration/braintree/payment_method_us_bank_account_spec.rb

@@ -96,7 +96,7 @@ describe Braintree::PaymentMethod do
           expect(us_bank_account.routing_number).to eq("123456789")
           expect(us_bank_account.last_4).to eq("0000")
           expect(us_bank_account.account_type).to eq("checking")
-          expect(us_bank_account.account_holder_name).to eq("Dan Schulman")
+          expect(us_bank_account.account_holder_name).to eq("Marty McFly")
           expect(us_bank_account.bank_name).to match(/Wells Fargo/)
           expect(us_bank_account.default).to eq(true)
           expect(us_bank_account.ach_mandate.accepted_at).to be_a Time

data/spec/integration/braintree/test_transaction_spec.rb

@@ -6,7 +6,7 @@ describe Braintree::TestTransaction do
     it "changes transaction status to settled" do
       sale_result = Braintree::Transaction.sale(
         :amount => "100",
-        :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutVisa,
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
         :options => {
         :submit_for_settlement => true
       },
@@ -22,7 +22,7 @@ describe Braintree::TestTransaction do
     it "changes transaction status to settlement_confirmed" do
       sale_result = Braintree::Transaction.sale(
         :amount => "100",
-        :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutVisa,
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
         :options => {
           :submit_for_settlement => true
         },
@@ -38,7 +38,7 @@ describe Braintree::TestTransaction do
     it "changes transaction status to settlement_declined" do
       sale_result = Braintree::Transaction.sale(
         :amount => "100",
-        :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutVisa,
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
         :options => {
           :submit_for_settlement => true
         },
@@ -54,7 +54,7 @@ describe Braintree::TestTransaction do
     it "changes transaction status to settlement_pending" do
       sale_result = Braintree::Transaction.sale(
         :amount => "100",
-        :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutVisa,
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
         :options => {
           :submit_for_settlement => true
         },
@@ -70,7 +70,7 @@ describe Braintree::TestTransaction do
     it "returns a validation error when invalid transition is specified" do
       sale_result = Braintree::Transaction.sale(
         :amount => "100",
-        :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutVisa,
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
       )
       expect(sale_result.success?).to eq(true)
 
@@ -110,7 +110,7 @@ describe Braintree::TestTransaction do
 
           sale_result = transaction_gateway.sale(
             :amount => "100",
-            :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutVisa,
+            :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
           )
           testing_gateway.settle(sale_result.transaction.id)
         end

data/spec/integration/braintree/transaction_search_spec.rb

@@ -856,7 +856,7 @@ describe Braintree::Transaction, "search" do
             search.ach_return_responses_created_at.between(DateTime.now - 1.0, DateTime.now + 1.0)
           end
 
-          expect(date_search.maximum_size).to eq(4)
+          expect(date_search.maximum_size).to be >= 1
         end
 
         it "it does not find records not within date range of the custom field" do

data/spec/integration/braintree/transaction_spec.rb

@@ -812,6 +812,22 @@ describe Braintree::Transaction do
         expect(result.transaction.foreign_retailer).to be_nil
       end
 
+      it "returns true for partial_authorization if the processor_response_code is 1004" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::PartiallyAuthorized,
+          :accept_partial_authorization => true,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2029"
+          },
+        )
+
+        expect(result.success?).to eq(true)
+        expect(result.transaction.processor_response_code).to eq("1004")
+        expect(result.transaction.partially_authorized).to eq(true)
+      end
+
       it "returns nil when foreign_retailer param is nil" do
         result = Braintree::Transaction.create(
           :type => "sale",
@@ -1216,27 +1232,32 @@ describe Braintree::Transaction do
           :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"],
+
+        code = Braintree::OAuthTestHelper.create_grant(gateway, {
+          :merchant_public_id => "partner_merchant_id",
+          :scope => "read_write"
+        })
+
+        result = gateway.oauth.create_token_from_code(
+          :code => code,
+          :scope => "read_write",
         )
 
-        gateway = Braintree::Gateway.new(
+        merchant_gateway = Braintree::Gateway.new(
           :access_token => result.credentials.access_token,
           :logger => Logger.new("/dev/null"),
         )
 
-        result = gateway.transaction.create(
+        transaction_result = merchant_gateway.transaction.create(
           :type => "sale",
-          :amount => "4000.00",
+          :amount => "5001.00",
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/2020"
           },
         )
-        expect(result.success?).to eq(false)
-        expect(result.transaction.gateway_rejection_reason).to eq(Braintree::Transaction::GatewayRejectionReason::ApplicationIncomplete)
+        expect(transaction_result.success?).to eq(false)
+        expect(transaction_result.transaction.gateway_rejection_reason).to eq(Braintree::Transaction::GatewayRejectionReason::ApplicationIncomplete)
       end
 
       it "exposes the avs gateway rejection reason" do
@@ -2335,8 +2356,9 @@ describe Braintree::Transaction do
         expect(google_pay_details).not_to be_nil
         expect(google_pay_details.card_type).to eq(Braintree::CreditCard::CardType::MasterCard)
         expect(google_pay_details.virtual_card_type).to eq(Braintree::CreditCard::CardType::MasterCard)
-        expect(google_pay_details.last_4).to eq("0005")
-        expect(google_pay_details.virtual_card_last_4).to eq("0005")
+        expect(google_pay_details.last_4).to eq("4444")
+        expect(google_pay_details.virtual_card_last_4).to eq("4444")
+        expect(google_pay_details.source_card_last_4).to eq("0005")
         expect(google_pay_details.source_description).to eq("MasterCard 0005")
         expect(google_pay_details.expiration_month.to_i).to be > 0
         expect(google_pay_details.expiration_year.to_i).to be > 0
@@ -3038,8 +3060,9 @@ describe Braintree::Transaction do
             :ds_transaction_id => "some_ds_id",
           },
         )
+
         expect(result.success?).to eq(false)
-        expect(result.errors.for(:transaction).for(:three_d_secure_pass_thru).on(:cavv_algorithm)[0].code).to eq(Braintree::ErrorCodes::Transaction::ThreeDSecureCavvAlgorithmIsInvalid)
+        expect(result.errors.for(:transaction).for(:credit_card).on(:cvv)[0].code).to eq(Braintree::ErrorCodes::CreditCard::CvvIsRequired)
       end
     end
 
@@ -7768,7 +7791,7 @@ describe Braintree::Transaction do
 
         expect(adjustment_transaction.success?).to eq(false)
         expect(adjustment_transaction.transaction.amount).to eq(BigDecimal("75.50"))
-        expect(adjustment_transaction.errors.for(:authorization_adjustment).on(:amount).first.code).to eq(Braintree::ErrorCodes::Transaction::AdjustmentAmountMustBeGreaterThanZero)
+        expect(adjustment_transaction.errors.for(:transaction).on(:amount).first.code).to eq(Braintree::ErrorCodes::Transaction::AmountMustBeGreaterThanZero)
       end
 
       it "returns failure response, when adjusted amount submitted same as authorized amount" do

data/spec/integration/braintree/transaction_transfer_type_spec.rb

@@ -15,7 +15,31 @@ describe Braintree::Transaction do
         },
         :transfer => {
           :type => "wallet_transfer",
-        },
+          :receiver => {
+            :first_name => "John",
+            :last_name => "Smith",
+            :middle_name => "D",
+            :address => {
+              :country_code_alpha2 => "US",
+              :locality => "LA",
+              :region => "CA",
+              :street_address => "1st Main"
+            }
+          },
+          :sender => {
+            :account_reference_number => "123456789",
+            :date_of_birth => Date.new(2002, 1, 2),
+            :first_name => "Lisa",
+            :last_name => "Ray",
+            :middle_name => "D",
+            :address => {
+              :country_code_alpha2 => "US",
+              :locality => "LA",
+              :region => "CA",
+              :street_address => "12th Main"
+            }
+          },
+        }
       }
 
       result = Braintree::Transaction.sale(transaction_params)

data/spec/integration/braintree/transaction_us_bank_account_spec.rb

@@ -143,6 +143,24 @@ describe Braintree::Transaction do
             expect(transaction.us_bank_account_details.ach_mandate.accepted_at).to be_a Time
           end
 
+          it "returns ach_type and requested_ach_type on transaction create" do
+            result = Braintree::Transaction.create(
+              :type => "sale",
+              :amount => Braintree::Test::TransactionAmounts::Authorize,
+              :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+              :payment_method_nonce => non_plaid_nonce,
+              :options => {
+                :submit_for_settlement => true,
+                :us_bank_account => {
+                  :ach_type => "same_day",
+                },
+              },
+            )
+            expect(result.success?).to eq(true)
+            expect(result.transaction.ach_type).to eq("same_day")
+            expect(result.transaction.requested_ach_type).to eq("same_day")
+          end
+
           it "sale fails for invalid nonce" do
             result = Braintree::Transaction.create(
               :type => "sale",
@@ -192,4 +210,27 @@ describe Braintree::Transaction do
       end
     end
   end
+
+  describe "self.find" do
+    it "returns ach_type and requested_ach_type for same_day ach with same_day requested" do
+      transaction = Braintree::Transaction.find("sameday_ach_sameday_requested")
+
+      expect(transaction.ach_type).to eq("same_day")
+      expect(transaction.requested_ach_type).to eq("same_day")
+    end
+
+    it "returns ach_type and requested_ach_type for standard ach with same_day requested" do
+      transaction = Braintree::Transaction.find("standard_ach_sameday_requested")
+
+      expect(transaction.ach_type).to eq("standard")
+      expect(transaction.requested_ach_type).to eq("same_day")
+    end
+
+    it "returns ach_type and requested_ach_type for standard ach with standard requested" do
+      transaction = Braintree::Transaction.find("standard_ach_standard_requested")
+
+      expect(transaction.ach_type).to eq("standard")
+      expect(transaction.requested_ach_type).to eq("standard")
+    end
+  end
 end

data/spec/integration/braintree/us_bank_account_verification_spec.rb

@@ -50,7 +50,7 @@ describe Braintree::UsBankAccountVerification do
         expect(response).to be_success
         expect(response.us_bank_account_verification.status).to eq(Braintree::UsBankAccountVerification::Status::Verified)
 
-        us_bank_account = Braintree::UsBankAccount.find(response.us_bank_account_verification.us_bank_account[:token])
+        us_bank_account = Braintree::UsBankAccount.find(response.us_bank_account_verification.us_bank_account.token)
 
         expect(us_bank_account.verified).to be_truthy
       end

data/spec/integration/braintree/visa_checkout_card_spec.rb

@@ -1,110 +1,14 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
 
+# DEPRECATED: Visa Checkout is no longer supported for creating new transactions.
+# Search functionality is retained for historical transactions only.
 describe Braintree::VisaCheckoutCard do
-  it "can create from payment method nonce" do
-    customer = Braintree::Customer.create!
-
-    result = Braintree::PaymentMethod.create(
-      :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
-      :customer_id => customer.id,
-    )
-    expect(result).to be_success
-
-    visa_checkout_card = result.payment_method
-    expect(visa_checkout_card).to be_a(Braintree::VisaCheckoutCard)
-    expect(visa_checkout_card.call_id).to eq("abc123")
-    expect(visa_checkout_card.billing_address).not_to be_nil
-    expect(visa_checkout_card.bin).not_to be_nil
-    expect(visa_checkout_card.card_type).not_to be_nil
-    expect(visa_checkout_card.cardholder_name).not_to be_nil
-    expect(visa_checkout_card.commercial).not_to be_nil
-    expect(visa_checkout_card.country_of_issuance).not_to be_nil
-    expect(visa_checkout_card.created_at).not_to be_nil
-    expect(visa_checkout_card.customer_id).not_to be_nil
-    expect(visa_checkout_card.customer_location).not_to be_nil
-    expect(visa_checkout_card.debit).not_to be_nil
-    expect(visa_checkout_card.default?).not_to be_nil
-    expect(visa_checkout_card.durbin_regulated).not_to be_nil
-    expect(visa_checkout_card.expiration_date).not_to be_nil
-    expect(visa_checkout_card.expiration_month).not_to be_nil
-    expect(visa_checkout_card.expiration_year).not_to be_nil
-    expect(visa_checkout_card.expired?).not_to be_nil
-    expect(visa_checkout_card.healthcare).not_to be_nil
-    expect(visa_checkout_card.image_url).not_to be_nil
-    expect(visa_checkout_card.issuing_bank).not_to be_nil
-    expect(visa_checkout_card.last_4).not_to be_nil
-    expect(visa_checkout_card.payroll).not_to be_nil
-    expect(visa_checkout_card.prepaid).not_to be_nil
-    expect(visa_checkout_card.product_id).not_to be_nil
-    expect(visa_checkout_card.subscriptions).not_to be_nil
-    expect(visa_checkout_card.token).not_to be_nil
-    expect(visa_checkout_card.unique_number_identifier).not_to be_nil
-    expect(visa_checkout_card.updated_at).not_to be_nil
-
-    customer = Braintree::Customer.find(customer.id)
-    expect(customer.visa_checkout_cards.size).to eq(1)
-    expect(customer.visa_checkout_cards.first).to eq(visa_checkout_card)
-  end
-
-  it "can create with verification" do
-    customer = Braintree::Customer.create!
-
-    result = Braintree::PaymentMethod.create(
-      :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
-      :customer_id => customer.id,
-      :options => {:verify_card => true},
-    )
-    expect(result).to be_success
-    expect(result.payment_method.verification.status).to eq(Braintree::CreditCardVerification::Status::Verified)
-  end
-
-  it "can search for transactions" do
-    transaction_create_result = Braintree::Transaction.sale(
-      :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
-      :amount => "47.00",
-    )
-    expect(transaction_create_result).to be_success
-    transaction_id = transaction_create_result.transaction.id
-
+  it "can search by payment instrument type" do
     search_results = Braintree::Transaction.search do |search|
-      search.id.is transaction_id
       search.payment_instrument_type.is Braintree::PaymentInstrumentType::VisaCheckoutCard
     end
-    expect(search_results.first.id).to eq(transaction_id)
-  end
-
-  it "can create transaction from nonce and vault" do
-    customer = Braintree::Customer.create!
-
-    result = Braintree::Transaction.sale(
-      :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
-      :customer_id => customer.id,
-      :amount => "47.00",
-      :options => {:store_in_vault => true},
-    )
-    expect(result).to be_success
 
-    visa_checkout_card_details = result.transaction.visa_checkout_card_details
-    expect(visa_checkout_card_details.call_id).to eq("abc123")
-    expect(visa_checkout_card_details.bin).not_to be_nil
-    expect(visa_checkout_card_details.card_type).not_to be_nil
-    expect(visa_checkout_card_details.cardholder_name).not_to be_nil
-    expect(visa_checkout_card_details.commercial).not_to be_nil
-    expect(visa_checkout_card_details.country_of_issuance).not_to be_nil
-    expect(visa_checkout_card_details.customer_location).not_to be_nil
-    expect(visa_checkout_card_details.debit).not_to be_nil
-    expect(visa_checkout_card_details.durbin_regulated).not_to be_nil
-    expect(visa_checkout_card_details.expiration_date).not_to be_nil
-    expect(visa_checkout_card_details.expiration_month).not_to be_nil
-    expect(visa_checkout_card_details.expiration_year).not_to be_nil
-    expect(visa_checkout_card_details.healthcare).not_to be_nil
-    expect(visa_checkout_card_details.image_url).not_to be_nil
-    expect(visa_checkout_card_details.issuing_bank).not_to be_nil
-    expect(visa_checkout_card_details.last_4).not_to be_nil
-    expect(visa_checkout_card_details.payroll).not_to be_nil
-    expect(visa_checkout_card_details.prepaid).not_to be_nil
-    expect(visa_checkout_card_details.product_id).not_to be_nil
-    expect(visa_checkout_card_details.token).not_to be_nil
+    expect(search_results).not_to be_nil
   end
 end

data/spec/spec_helper.rb

@@ -4,6 +4,7 @@ unless defined?(SPEC_HELPER_LOADED)
   require "rubygems"
   require "bundler/setup"
   require "rspec"
+  require "rspec/retry"
   require "pry"
 
   braintree_lib = "#{project_root}/lib"
@@ -119,18 +120,40 @@ unless defined?(SPEC_HELPER_LOADED)
       response[:three_d_secure_verification][:three_d_secure_authentication_id]
     end
 
-    def self.create_merchant(params={})
+    def self.get_merchant(params={})
       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"),
       )
 
-      gateway.merchant.create({
-        :email => "name@email.com",
-        :country_code_alpha3 => "GBR",
-        :payment_methods => ["credit_card", "paypal"],
-      }.merge!(params))
+      code = Braintree::OAuthTestHelper.create_grant(gateway, {
+        :merchant_public_id => "partner_merchant_id",
+        :scope => "read_write"
+      })
+
+      result = gateway.oauth.create_token_from_code(
+        :code => code,
+        :scope => "read_write",
+      )
+
+      merchant_gateway = Braintree::Gateway.new(
+        :access_token => result.credentials.access_token,
+        :logger => Logger.new("/dev/null"),
+      )
+
+      ma_result = merchant_gateway.merchant_account.all
+
+      merchant_obj = OpenStruct.new(
+        :id => "partner_merchant_id",
+        :merchant_accounts => ma_result.merchant_accounts,
+      )
+
+      OpenStruct.new(
+        :success? => true,
+        :credentials => result.credentials,
+        :merchant => merchant_obj,
+      )
     end
 
     def self.stub_time_dot_now(desired_time)
@@ -234,4 +257,9 @@ RSpec.configure do |config|
   config.mock_with :rspec do |mock|
     mock.syntax = [:should, :expect]
   end
+
+  config.verbose_retry = true
+  config.display_try_failure_messages = true
+  config.default_retry_count = 3
+  config.default_sleep_interval = 1
 end

data/spec/unit/braintree/client_token_spec.rb

@@ -33,5 +33,16 @@ module Braintree
         end
       end
     end
+
+    describe "error response handling" do
+      it "correctly parses error response with nested structure" do
+        error_xml = "<api-error-response><message>Invalid request</message><errors><errors type=\"array\"></errors></errors></api-error-response>"
+        result = Braintree::Xml::Parser.hash_from_xml(error_xml)
+
+        expect(result[:api_error_response]).to be_a(Hash)
+        expect(result[:api_error_response][:message]).to eq("Invalid request")
+        expect(result[:api_error_response][:errors]).to be_a(Hash)
+      end
+    end
   end
 end

data/spec/unit/braintree/error_result_spec.rb

@@ -14,6 +14,34 @@ describe Braintree::ErrorResult do
         )
       end.to_not raise_error
     end
+
+    it "handles parsed XML error response structure correctly" do
+      data = {
+        :message => "Validation failed",
+        :errors => {
+          :errors => [{:code => "81234", :message => "Field is required"}]
+        }
+      }
+
+      expect do
+        result = Braintree::ErrorResult.new(:gateway, data)
+        expect(result.message).to eq("Validation failed")
+        expect(result.errors.inspect).to eq("#<Braintree::Errors :[(81234) Field is required]>")
+      end.to_not raise_error
+    end
+
+    it "handles empty error array in parsed XML response" do
+      data = {
+        :message => "Invalid request",
+        :errors => {:errors => []}
+      }
+
+      expect do
+        result = Braintree::ErrorResult.new(:gateway, data)
+        expect(result.message).to eq("Invalid request")
+        expect(result.errors).to be_a(Braintree::Errors)
+      end.to_not raise_error
+    end
   end
 
   describe "inspect" do

data/spec/unit/braintree/transaction_gateway_spec.rb

@@ -33,7 +33,7 @@ describe Braintree::TransactionGateway do
     # three_d_secure_token has been deprecated in favor of three_d_secure_authentication_id
     it "creates a transaction gateway signature" do
       expect(Braintree::TransactionGateway._create_signature).to match([
-        :amount, :billing_address_id, :channel, :currency_iso_code, :customer_id, :device_data,
+        :accept_partial_authorization, :amount, :billing_address_id, :channel, :currency_iso_code, :customer_id, :device_data,
         :discount_amount, :exchange_rate_quote_id, :foreign_retailer,
         :merchant_account_id, :order_id, :payment_method_nonce, :payment_method_token, :processing_merchant_category_code,
         :product_sku, :purchase_order_number, :service_fee_amount, :shared_billing_address_id,
@@ -89,6 +89,7 @@ describe Braintree::TransactionGateway do
           :store_shipping_address_in_vault,
           :submit_for_settlement,
           {:three_d_secure => [:required]},
+          {:us_bank_account => [:ach_type]},
           {:venmo => [:profile_id]},
           :venmo_sdk_session, # Deprecated
         ]
@@ -133,16 +134,19 @@ describe Braintree::TransactionGateway do
           :transfer => [
             :type,
             {:sender => [
+              :account_reference_number,
+              :date_of_birth,
               :first_name,
               :last_name,
-              :account_reference_number,
+              :middle_name,
               :tax_id,
               :address => Braintree::AddressGateway._address_attributes
             ]},
             {:receiver => [
+              :account_reference_number,
               :first_name,
               :last_name,
-              :account_reference_number,
+              :middle_name,
               :tax_id,
               :address => Braintree::AddressGateway._address_attributes
             ]},

data/spec/unit/braintree/transaction_spec.rb

@@ -347,6 +347,15 @@ describe Braintree::Transaction do
       expect(transaction.network_transaction_id).to eq("123456789012345")
     end
 
+    it "sets partially_authorized to true if processor_response_code is 1004" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :processor_response_code => "1004",
+      )
+      expect(transaction.processor_response_code).to eq("1004")
+      expect(transaction.partially_authorized).to eq(true)
+    end
+
     it "accepts ach_return_code" do
       transaction = Braintree::Transaction._new(
         :gateway,
@@ -365,6 +374,16 @@ describe Braintree::Transaction do
       expect(transaction.ach_reject_reason).to eq("some reject reason")
     end
 
+    it "accepts ach_type" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :ach_type => "standard",
+        :requested_ach_type => "standard",
+      )
+      expect(transaction.ach_type).to eq("standard")
+      expect(transaction.requested_ach_type).to eq("standard")
+    end
+
     it "accepts network_response code and network_response_text" do
       transaction = Braintree::Transaction._new(
         :gateway,

data/spec/unit/braintree/visa_checkout_card_spec.rb

@@ -1,5 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
+# DEPRECATED: Visa Checkout Transactions are no longer supported
 describe Braintree::VisaCheckoutCard do
   it "initializes prepaid reloadable correctly" do
     card = Braintree::VisaCheckoutCard._new(:gateway, {:prepaid_reloadable => "No"})

data/spec/unit/braintree/xml/parser_spec.rb

@@ -81,5 +81,62 @@ describe Braintree::Xml::Parser do
       END
       expect(xml).to parse_to(:root => {:paypal_details => {:deets => [{:secret_code => "1234"}], :payer_email => "abc@test.com", :payment_id => "1234567890"}})
     end
+
+    it "does not collapse nested structures with single-child elements" do
+      xml = "<api-error-response><message>Test</message><errors><errors type=\"array\"></errors></errors></api-error-response>"
+      expect(xml).to parse_to({:api_error_response=>{:message=>"Test", :errors=>{:errors=>[]}}})
+    end
+
+    it "preserves hash structure when one key has array value" do
+      xml = <<-END
+        <root>
+          <message>Error message</message>
+          <items type="array">
+            <item>Value1</item>
+          </items>
+        </root>
+      END
+      expect(xml).to parse_to({:root => {:message => "Error message", :items => ["Value1"]}})
+    end
+
+    it "handles error response with nested errors correctly" do
+      xml = <<-END
+        <api-error-response>
+          <message>Validation failed</message>
+          <errors>
+            <errors type="array">
+              <error>
+                <code>81234</code>
+                <message>Field is required</message>
+              </error>
+            </errors>
+          </errors>
+        </api-error-response>
+      END
+      expect(xml).to parse_to({
+        :api_error_response => {
+          :message => "Validation failed",
+          :errors => {
+            :errors => [{:code => "81234", :message => "Field is required"}]
+          }
+        }
+      })
+    end
+
+    it "handles client token error response structure" do
+      xml = <<-END
+        <api-error-response>
+          <message>Invalid request</message>
+          <errors>
+            <errors type="array"></errors>
+          </errors>
+        </api-error-response>
+      END
+      result = Braintree::Xml::Parser.hash_from_xml(xml)
+      expect(result[:api_error_response]).to be_a(Hash)
+      expect(result[:api_error_response][:message]).to eq("Invalid request")
+      expect(result[:api_error_response][:errors]).to be_a(Hash)
+      expect(result[:api_error_response][:errors][:errors]).to eq([])
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: braintree
 version: !ruby/object:Gem::Version
-  version: 4.33.0
+  version: 4.35.0
 platform: ruby
 authors:
 - Braintree
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-10-24 00:00:00.000000000 Z
+date: 2026-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -405,7 +405,7 @@ metadata:
   changelog_uri: https://github.com/braintree/braintree_ruby/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/braintree/braintree_ruby
   documentation_uri: https://developer.paypal.com/braintree/docs
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -420,8 +420,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.5
-signing_key: 
+rubygems_version: 3.3.15
+signing_key:
 specification_version: 4
 summary: Braintree Ruby Server SDK
 test_files: []