braintree 4.23.0 → 4.34.0

data/spec/unit/braintree/transaction/meta_checkout_card_details_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::MetaCheckoutCardDetails do
+  it "initializes prepaid reloadable correctly" do
+    card = Braintree::MetaCheckoutCardDetails._new(:gateway, {:prepaid_reloadable => "No"})
+    expect(card.prepaid_reloadable).to eq("No")
+  end
+
+  it "initializes business correctly" do
+    card = Braintree::MetaCheckoutCardDetails._new(:gateway, {:business => "No"})
+    expect(card.business).to eq("No")
+  end
+
+  it "initializes consumer correctly" do
+    card = Braintree::MetaCheckoutCardDetails._new(:gateway, {:consumer => "No"})
+    expect(card.consumer).to eq("No")
+  end
+
+  it "initializes corporate correctly" do
+    card = Braintree::MetaCheckoutCardDetails._new(:gateway, {:corporate => "No"})
+    expect(card.corporate).to eq("No")
+  end
+
+  it "initializes purchase correctly" do
+    card = Braintree::MetaCheckoutCardDetails._new(:gateway, {:purchase => "No"})
+    expect(card.purchase).to eq("No")
+  end
+end

data/spec/unit/braintree/transaction/meta_checkout_token_details_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::MetaCheckoutTokenDetails do
+  it "initializes prepaid reloadable correctly" do
+    card = Braintree::MetaCheckoutTokenDetails._new(:gateway, {:prepaid_reloadable => "No"})
+    expect(card.prepaid_reloadable).to eq("No")
+  end
+
+  it "initializes business correctly" do
+    card = Braintree::MetaCheckoutTokenDetails._new(:gateway, {:business => "No"})
+    expect(card.business).to eq("No")
+  end
+
+  it "initializes consumer correctly" do
+    card = Braintree::MetaCheckoutTokenDetails._new(:gateway, {:consumer => "No"})
+    expect(card.consumer).to eq("No")
+  end
+
+  it "initializes corporate correctly" do
+    card = Braintree::MetaCheckoutTokenDetails._new(:gateway, {:corporate => "No"})
+    expect(card.corporate).to eq("No")
+  end
+
+  it "initializes purchase correctly" do
+    card = Braintree::MetaCheckoutTokenDetails._new(:gateway, {:purchase => "No"})
+    expect(card.purchase).to eq("No")
+  end
+end

data/spec/unit/braintree/transaction/paypal_details_spec.rb

@@ -21,6 +21,8 @@ describe Braintree::Transaction::PayPalDetails do
         :payer_last_name => "Hopper",
         :payer_status =>"status",
         :payment_id => "payment-id",
+        :recipient_email => "test@paypal.com",
+        :recipient_phone => [:country_code => "1", :national_number => "4082222222"],
         :refund_from_transaction_fee_amount => "1.00",
         :refund_from_transaction_fee_currency_iso_code => "123",
         :refund_id => "refund-id",
@@ -49,6 +51,9 @@ describe Braintree::Transaction::PayPalDetails do
       expect(details.payer_last_name).to eq("Hopper")
       expect(details.payer_status).to eq("status")
       expect(details.payment_id).to eq("payment-id")
+      expect(details.recipient_email).to eq("test@paypal.com")
+      expect(details.recipient_phone.country_code).to eq("1")
+      expect(details.recipient_phone.national_number).to eq("4082222222")
       expect(details.refund_from_transaction_fee_amount).to eq("1.00")
       expect(details.refund_from_transaction_fee_currency_iso_code).to eq("123")
       expect(details.refund_id).to eq("refund-id")

data/spec/unit/braintree/transaction/visa_checkout_card_details_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::VisaCheckoutCardDetails do
+  it "initializes prepaid reloadable correctly" do
+    card = Braintree::VisaCheckoutCardDetails._new(:gateway, {:prepaid_reloadable => "No"})
+    expect(card.prepaid_reloadable).to eq("No")
+  end
+
+  it "initializes business correctly" do
+    card = Braintree::VisaCheckoutCardDetails._new(:gateway, {:business => "No"})
+    expect(card.business).to eq("No")
+  end
+
+  it "initializes consumer correctly" do
+    card = Braintree::VisaCheckoutCardDetails._new(:gateway, {:consumer => "No"})
+    expect(card.consumer).to eq("No")
+  end
+
+  it "initializes corporate correctly" do
+    card = Braintree::VisaCheckoutCardDetails._new(:gateway, {:corporate => "No"})
+    expect(card.corporate).to eq("No")
+  end
+
+  it "initializes purchase correctly" do
+    card = Braintree::VisaCheckoutCardDetails._new(:gateway, {:purchase => "No"})
+    expect(card.purchase).to eq("No")
+  end
+end

data/spec/unit/braintree/transaction_ach_mandate_spec.rb

@@ -0,0 +1,82 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe "Transaction ACH Mandate" do
+  describe "transaction request handling" do
+    let(:gateway) { Braintree::Gateway.new(:environment => :sandbox, :merchant_id => "test", :public_key => "test", :private_key => "test") }
+    let(:transaction_gateway) { gateway.transaction }
+
+    it "processes us_bank_account ACH mandate fields" do
+      mandate_time = Time.now
+
+      # Mock the HTTP response for transaction creation
+      allow(gateway.config.http).to receive(:post).and_return({
+        :transaction => {
+          :id => "test_transaction_id",
+          :amount => "100.00",
+          :status => "authorized",
+          :us_bank_account => {
+            :token => "test_token",
+            :ach_mandate => {
+              :text => "I authorize this ACH debit",
+              :accepted_at => mandate_time.iso8601
+            }
+          }
+        }
+      })
+
+      transaction_attributes = {
+        :amount => "100.00",
+        :payment_method_token => "test_token",
+        :us_bank_account => {
+          :ach_mandate_text => "I authorize this ACH debit",
+          :ach_mandate_accepted_at => mandate_time
+        }
+      }
+
+      # This should not raise an error due to signature validation
+      expect {
+        Braintree::Util.verify_keys(Braintree::TransactionGateway._create_signature, transaction_attributes)
+      }.not_to raise_error
+    end
+
+    it "allows ACH mandate text only" do
+      transaction_attributes = {
+        :amount => "50.00",
+        :payment_method_token => "test_token",
+        :us_bank_account => {
+          :ach_mandate_text => "I authorize this ACH debit"
+        }
+      }
+
+      expect {
+        Braintree::Util.verify_keys(Braintree::TransactionGateway._create_signature, transaction_attributes)
+      }.not_to raise_error
+    end
+
+    it "allows ACH mandate accepted_at only" do
+      transaction_attributes = {
+        :amount => "50.00",
+        :payment_method_token => "test_token",
+        :us_bank_account => {
+          :ach_mandate_accepted_at => Time.now
+        }
+      }
+
+      expect {
+        Braintree::Util.verify_keys(Braintree::TransactionGateway._create_signature, transaction_attributes)
+      }.not_to raise_error
+    end
+
+    it "allows empty us_bank_account hash" do
+      transaction_attributes = {
+        :amount => "50.00",
+        :payment_method_token => "test_token",
+        :us_bank_account => {}
+      }
+
+      expect {
+        Braintree::Util.verify_keys(Braintree::TransactionGateway._create_signature, transaction_attributes)
+      }.not_to raise_error
+    end
+  end
+end

data/spec/unit/braintree/transaction_gateway_spec.rb

@@ -35,7 +35,7 @@ describe Braintree::TransactionGateway do
       expect(Braintree::TransactionGateway._create_signature).to match([
         :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,
+        :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,
         :shared_customer_id, :shared_payment_method_nonce, :shared_payment_method_token,
         :shared_shipping_address_id, :shipping_address_id, :shipping_amount, :shipping_tax_amount,
@@ -73,27 +73,46 @@ describe Braintree::TransactionGateway do
         {:installments => [:count]},
         {:line_items => [:commodity_code, :description, :discount_amount, :image_url, :kind, :name, :product_code, :quantity, :tax_amount, :total_amount, :unit_amount, :unit_of_measure, :unit_tax_amount, :upc_code, :upc_type, :url]},
         {:options => [
-          :hold_in_escrow,
-          :store_in_vault,
-          :store_in_vault_on_success,
-          :submit_for_settlement,
           :add_billing_address_to_payment_method,
-          :store_shipping_address_in_vault,
-          :venmo_sdk_session, # Deprecated
+          {:amex_rewards => [:request_id, :points, :currency_amount, :currency_iso_code]},
+          {:credit_card => [:account_type, :process_debit_as_credit]},
+          :hold_in_escrow,
           :payee_id,
           :payee_email,
+          {:paypal => [:custom_field, :description, :payee_id, :payee_email,  :recipient_email,  {:recipient_phone => [:country_code, :national_number]},  {:supplementary_data => :_any_key_}]},
+          {:processing_overrides => [:customer_email, :customer_first_name, :customer_last_name, :customer_tax_identifier]},
           :skip_advanced_fraud_checking,
           :skip_avs,
           :skip_cvv,
-          {:paypal => [:custom_field, :payee_id, :payee_email, :description, {:supplementary_data => :_any_key_}]},
-          {:processing_overrides => [:customer_email, :customer_first_name, :customer_last_name, :customer_tax_identifier]},
+          :store_in_vault,
+          :store_in_vault_on_success,
+          :store_shipping_address_in_vault,
+          :submit_for_settlement,
           {:three_d_secure => [:required]},
-          {:amex_rewards => [:request_id, :points, :currency_amount, :currency_iso_code]},
           {:venmo => [:profile_id]},
-          {:credit_card => [:account_type, :process_debit_as_credit]},
+          :venmo_sdk_session, # Deprecated
         ]
         },
         {:paypal_account => [:email, :token, :paypal_data, :payee_id, :payee_email, :payer_id, :payment_id]},
+        {:payment_facilitator => [
+          :payment_facilitator_id,
+          {:sub_merchant => [
+            :reference_number,
+            :tax_id,
+            :legal_name,
+            {:address => [
+              :street_address,
+              :locality,
+              :region,
+              :country_code_alpha2,
+              :postal_code,
+              {:international_phone => [
+                :country_code,
+                :national_number
+              ]}
+            ]}
+          ]}
+        ]},
         {:risk_data => [:customer_browser, :customer_device_id, :customer_ip, :customer_location_zip, :customer_tenure]},
         {
           :shipping => Braintree::AddressGateway._shared_signature + [:shipping_method],
@@ -110,6 +129,34 @@ describe Braintree::TransactionGateway do
             :ds_transaction_id,
           ]
         },
+        {
+          :transfer => [
+            :type,
+            {:sender => [
+              :account_reference_number,
+              :date_of_birth,
+              :first_name,
+              :last_name,
+              :middle_name,
+              :tax_id,
+              :address => Braintree::AddressGateway._address_attributes
+            ]},
+            {:receiver => [
+              :account_reference_number,
+              :first_name,
+              :last_name,
+              :middle_name,
+              :tax_id,
+              :address => Braintree::AddressGateway._address_attributes
+            ]},
+          ]
+        },
+        {
+          :us_bank_account => [
+            :ach_mandate_text,
+            :ach_mandate_accepted_at,
+          ]
+        },
       ])
     end
 

data/spec/unit/braintree/transaction_spec.rb

@@ -119,12 +119,17 @@ describe Braintree::Transaction do
           :expiration_year => "2009",
           :customer_location => "US",
           :prepaid => "Yes",
+          :prepaid_reloadable => "Yes",
           :healthcare => "Yes",
           :durbin_regulated => "Yes",
           :debit => "Yes",
+          :business => "Yes",
           :commercial => "No",
+          :consumer => "No",
+          :corporate => "No",
           :payroll => "Unknown",
           :product_id => "Unknown",
+          :purchase => "No",
           :country_of_issuance => "Narnia",
           :issuing_bank => "Mr Tumnus"
         },
@@ -137,16 +142,59 @@ describe Braintree::Transaction do
       expect(transaction.credit_card_details.expiration_year).to eq("2009")
       expect(transaction.credit_card_details.customer_location).to eq("US")
       expect(transaction.credit_card_details.prepaid).to eq(Braintree::CreditCard::Prepaid::Yes)
+      expect(transaction.credit_card_details.prepaid_reloadable).to eq(Braintree::CreditCard::PrepaidReloadable::Yes)
       expect(transaction.credit_card_details.healthcare).to eq(Braintree::CreditCard::Healthcare::Yes)
       expect(transaction.credit_card_details.durbin_regulated).to eq(Braintree::CreditCard::DurbinRegulated::Yes)
       expect(transaction.credit_card_details.debit).to eq(Braintree::CreditCard::Debit::Yes)
+      expect(transaction.credit_card_details.business).to eq(Braintree::CreditCard::Business::Yes)
       expect(transaction.credit_card_details.commercial).to eq(Braintree::CreditCard::Commercial::No)
+      expect(transaction.credit_card_details.consumer).to eq(Braintree::CreditCard::Consumer::No)
+      expect(transaction.credit_card_details.corporate).to eq(Braintree::CreditCard::Corporate::No)
       expect(transaction.credit_card_details.payroll).to eq(Braintree::CreditCard::Payroll::Unknown)
       expect(transaction.credit_card_details.product_id).to eq(Braintree::CreditCard::ProductId::Unknown)
+      expect(transaction.credit_card_details.purchase).to eq(Braintree::CreditCard::Purchase::No)
       expect(transaction.credit_card_details.country_of_issuance).to eq("Narnia")
       expect(transaction.credit_card_details.issuing_bank).to eq("Mr Tumnus")
     end
 
+    describe "payment_account_reference in transaction details" do
+      it "exposes payment_account_reference in credit_card_details" do
+        transaction = Braintree::Transaction._new(
+          :gateway,
+          :credit_card => {
+            :bin => "401288",
+            :last_4 => "1881",
+            :card_type => "Visa",
+            :payment_account_reference => "V0010013019339005665779448477"
+          },
+        )
+        expect(transaction.credit_card_details.payment_account_reference).to eq("V0010013019339005665779448477")
+      end
+
+      it "exposes payment_account_reference in apple_pay_details" do
+        transaction = Braintree::Transaction._new(
+          :gateway,
+          :apple_pay => {
+            :payment_instrument_name => "Apple Pay",
+            :payment_account_reference => "V0010013019339005665779448477"
+          },
+        )
+        expect(transaction.apple_pay_details.payment_account_reference).to eq("V0010013019339005665779448477")
+      end
+
+      it "exposes payment_account_reference in google_pay_details" do
+        transaction = Braintree::Transaction._new(
+          :gateway,
+          :android_pay_card => {
+            :virtual_card_type => "Visa",
+            :payment_account_reference => "V0010013019339005665779448477"
+          },
+        )
+        expect(transaction.google_pay_details.payment_account_reference).to eq("V0010013019339005665779448477")
+      end
+
+    end
+
     it "sets up network token attributes in network_token_details" do
       transaction = Braintree::Transaction._new(
         :gateway,
@@ -257,6 +305,14 @@ describe Braintree::Transaction do
       expect(transaction.retried_transaction_id).to eq("original_retried_tranction_id")
     end
 
+    it "accepts upcoming_retry_date attribute in a transaction" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :upcoming_retry_date => "2024-12-25",
+      )
+      expect(transaction.upcoming_retry_date).to eq("2024-12-25")
+    end
+
     it "handles receiving custom as an empty string" do
       Braintree::Transaction._new(
         :gateway,
@@ -299,6 +355,16 @@ describe Braintree::Transaction do
       expect(transaction.ach_return_code).to eq("R01")
     end
 
+    it "accepts ach_reject_reason" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :ach_return_code => "RJCT",
+        :ach_reject_reason => "some reject reason",
+      )
+      expect(transaction.ach_return_code).to eq("RJCT")
+      expect(transaction.ach_reject_reason).to eq("some reject reason")
+    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

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::VisaCheckoutCard do
+  it "initializes prepaid reloadable correctly" do
+    card = Braintree::VisaCheckoutCard._new(:gateway, {:prepaid_reloadable => "No"})
+    expect(card.prepaid_reloadable).to eq("No")
+  end
+
+  it "initializes business correctly" do
+    card = Braintree::VisaCheckoutCard._new(:gateway, {:business => "No"})
+    expect(card.business).to eq("No")
+  end
+
+  it "initializes consumer correctly" do
+    card = Braintree::VisaCheckoutCard._new(:gateway, {:consumer => "No"})
+    expect(card.consumer).to eq("No")
+  end
+
+  it "initializes corporate correctly" do
+    card = Braintree::VisaCheckoutCard._new(:gateway, {:corporate => "No"})
+    expect(card.corporate).to eq("No")
+  end
+
+  it "initializes purchase correctly" do
+    card = Braintree::VisaCheckoutCard._new(:gateway, {:purchase => "No"})
+    expect(card.purchase).to eq("No")
+  end
+end

data/spec/unit/braintree/webhook_notification_spec.rb

@@ -310,42 +310,40 @@ describe Braintree::WebhookNotification do
         expect(notification.transaction.disbursement_details.disbursement_date).to eq(Date.parse("2013-07-09"))
       end
 
-      it "builds a sample notification for a disbursement_exception webhook" do
+      it "builds a sample notification for a disbursement webhook" do
         sample_notification = Braintree::WebhookTesting.sample_notification(
-          Braintree::WebhookNotification::Kind::DisbursementException,
+          Braintree::WebhookNotification::Kind::Disbursement,
           "my_id",
         )
 
         notification = Braintree::WebhookNotification.parse(sample_notification[:bt_signature], sample_notification[:bt_payload])
 
-        expect(notification.kind).to eq(Braintree::WebhookNotification::Kind::DisbursementException)
+        expect(notification.kind).to eq(Braintree::WebhookNotification::Kind::Disbursement)
         expect(notification.disbursement.id).to eq("my_id")
         expect(notification.disbursement.transaction_ids).to eq(%W{ afv56j kj8hjk })
         expect(notification.disbursement.retry).to be(false)
-        expect(notification.disbursement.success).to be(false)
-        expect(notification.disbursement.exception_message).to eq("bank_rejected")
+        expect(notification.disbursement.success).to be(true)
+        expect(notification.disbursement.exception_message).to be_nil
         expect(notification.disbursement.disbursement_date).to eq(Date.parse("2014-02-10"))
-        expect(notification.disbursement.follow_up_action).to eq("update_funding_information")
+        expect(notification.disbursement.follow_up_action).to be_nil
         expect(notification.disbursement.merchant_account.id).to eq("merchant_account_token")
       end
+    end
 
-      it "builds a sample notification for a disbursement webhook" do
+    context "transaction retried" do
+      it "builds a sample notification for a transaction retried webhook" do
         sample_notification = Braintree::WebhookTesting.sample_notification(
-          Braintree::WebhookNotification::Kind::Disbursement,
+          Braintree::WebhookNotification::Kind::TransactionRetried,
           "my_id",
         )
 
         notification = Braintree::WebhookNotification.parse(sample_notification[:bt_signature], sample_notification[:bt_payload])
 
-        expect(notification.kind).to eq(Braintree::WebhookNotification::Kind::Disbursement)
-        expect(notification.disbursement.id).to eq("my_id")
-        expect(notification.disbursement.transaction_ids).to eq(%W{ afv56j kj8hjk })
-        expect(notification.disbursement.retry).to be(false)
-        expect(notification.disbursement.success).to be(true)
-        expect(notification.disbursement.exception_message).to be_nil
-        expect(notification.disbursement.disbursement_date).to eq(Date.parse("2014-02-10"))
-        expect(notification.disbursement.follow_up_action).to be_nil
-        expect(notification.disbursement.merchant_account.id).to eq("merchant_account_token")
+        expect(notification.kind).to eq(Braintree::WebhookNotification::Kind::TransactionRetried)
+        expect(notification.transaction.id).to eq("my_id")
+        expect(notification.transaction.amount).to eq(1_00)
+        expect(notification.transaction.status).to eq("submitted_for_settlement")
+        expect(notification.transaction.retried_transaction_id).to eq("original_txn_id")
       end
     end
 
@@ -403,40 +401,6 @@ describe Braintree::WebhookNotification do
       end
     end
 
-    context "merchant account" do
-      it "builds a sample notification for a merchant account approved webhook" do
-        sample_notification = Braintree::WebhookTesting.sample_notification(
-          Braintree::WebhookNotification::Kind::SubMerchantAccountApproved,
-          "my_id",
-        )
-
-        notification = Braintree::WebhookNotification.parse(sample_notification[:bt_signature], sample_notification[:bt_payload])
-
-        expect(notification.kind).to eq(Braintree::WebhookNotification::Kind::SubMerchantAccountApproved)
-        expect(notification.merchant_account.id).to eq("my_id")
-        expect(notification.merchant_account.status).to eq(Braintree::MerchantAccount::Status::Active)
-        expect(notification.merchant_account.master_merchant_account.id).to eq("master_ma_for_my_id")
-        expect(notification.merchant_account.master_merchant_account.status).to eq(Braintree::MerchantAccount::Status::Active)
-      end
-
-      it "builds a sample notification for a merchant account declined webhook" do
-        sample_notification = Braintree::WebhookTesting.sample_notification(
-          Braintree::WebhookNotification::Kind::SubMerchantAccountDeclined,
-          "my_id",
-        )
-
-        notification = Braintree::WebhookNotification.parse(sample_notification[:bt_signature], sample_notification[:bt_payload])
-
-        expect(notification.kind).to eq(Braintree::WebhookNotification::Kind::SubMerchantAccountDeclined)
-        expect(notification.merchant_account.id).to eq("my_id")
-        expect(notification.merchant_account.status).to eq(Braintree::MerchantAccount::Status::Suspended)
-        expect(notification.merchant_account.master_merchant_account.id).to eq("master_ma_for_my_id")
-        expect(notification.merchant_account.master_merchant_account.status).to eq(Braintree::MerchantAccount::Status::Suspended)
-        expect(notification.message).to eq("Credit score is too low")
-        expect(notification.errors.for(:merchant_account).on(:base).first.code).to eq(Braintree::ErrorCodes::MerchantAccount::DeclinedOFAC)
-      end
-    end
-
     context "subscription" do
       it "builds a sample notification for a subscription billing skipped  webhook" do
         sample_notification = Braintree::WebhookTesting.sample_notification(

data/spec/unit/braintree/xml/{libxml_spec.rb → nokogiri_spec.rb}

@@ -1,10 +1,10 @@
 require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
 
-describe Braintree::Xml::Libxml do
+describe Braintree::Xml::Nokogiri do
   describe "self.parse" do
     it "typecasts integers" do
       xml = "<root><foo type=\"integer\">123</foo></root>"
-      expect(Braintree::Xml::Libxml.parse(xml)).to eq({"root"=>{"foo"=>{"__content__"=>"123", "type"=>"integer"}}})
+      expect(Braintree::Xml::Nokogiri.parse(xml)).to eq({"root"=>{"foo"=>{"__content__"=>"123", "type"=>"integer"}}})
     end
 
     it "works with dashes or underscores" do
@@ -14,7 +14,7 @@ describe Braintree::Xml::Libxml do
           <under_scores />
         </root>
       END
-      expect(Braintree::Xml::Libxml.parse(xml)).to eq({"root"=>{"dash-es"=>{}, "under_scores"=>{}}})
+      expect(Braintree::Xml::Nokogiri.parse(xml)).to eq({"root"=>{"dash-es"=>{}, "under_scores"=>{}}})
     end
 
     it "uses nil if nil=true, otherwise uses empty string" do
@@ -24,7 +24,7 @@ describe Braintree::Xml::Libxml do
           <an_empty_string></an_empty_string>
         </root>
       END
-      expect(Braintree::Xml::Libxml.parse(xml)).to eq({"root"=>{"a_nil_value"=>{"nil"=>"true"}, "an_empty_string"=>{}}})
+      expect(Braintree::Xml::Nokogiri.parse(xml)).to eq({"root"=>{"a_nil_value"=>{"nil"=>"true"}, "an_empty_string"=>{}}})
     end
 
     it "typecasts dates and times" do
@@ -33,7 +33,7 @@ describe Braintree::Xml::Libxml do
           <created-at type="datetime">2009-10-28T10:19:49Z</created-at>
         </root>
       END
-      expect(Braintree::Xml::Libxml.parse(xml)).to eq({"root"=>{"created-at"=>{"__content__"=>"2009-10-28T10:19:49Z", "type"=>"datetime"}}})
+      expect(Braintree::Xml::Nokogiri.parse(xml)).to eq({"root"=>{"created-at"=>{"__content__"=>"2009-10-28T10:19:49Z", "type"=>"datetime"}}})
     end
 
     it "builds an array if type=array" do
@@ -45,7 +45,7 @@ describe Braintree::Xml::Libxml do
           </customers>
         </root>
       END
-      expect(Braintree::Xml::Libxml.parse(xml)).to eq({"root"=>{"customers"=>{"type"=>"array", "customer"=>[{"name"=>{"__content__"=>"Adam"}}, {"name"=>{"__content__"=>"Ben"}}]}}})
+      expect(Braintree::Xml::Nokogiri.parse(xml)).to eq({"root"=>{"customers"=>{"type"=>"array", "customer"=>[{"name"=>{"__content__"=>"Adam"}}, {"name"=>{"__content__"=>"Ben"}}]}}})
     end
   end
-end
+end

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