braintree 4.38.0 → 4.40.0

data/spec/integration/braintree/transaction_spec.rb

@@ -336,7 +336,7 @@ describe Braintree::Transaction do
 
     describe "sca_exemption" do
       context "with a valid request" do
-        xit "succeeds" do
+        it "succeeds with a valid sca_exemption request" do
           requested_exemption = "low_value"
           result = Braintree::Transaction.create(
             :type => "sale",
@@ -1370,7 +1370,7 @@ describe Braintree::Transaction do
         expect(result.transaction.gateway_rejection_reason).to eq(Braintree::Transaction::GatewayRejectionReason::TokenIssuance)
       end
 
-      xit "exposes the excessive_retry gateway rejection reason" do
+      it "exposes the excessive_retry gateway rejection reason" do
         with_duplicate_checking_merchant do
           result = nil
           counter = 0
@@ -1749,7 +1749,7 @@ describe Braintree::Transaction do
         expect(result.transaction.descriptor.url).to eq("ebay.com")
       end
 
-      it "has validation errors if format is invalid" do
+      it "has validation errors when the descriptor name is too long" do
         result = Braintree::Transaction.sale(
           :amount => Braintree::Test::TransactionAmounts::Authorize,
           :credit_card => {
@@ -1757,7 +1757,7 @@ describe Braintree::Transaction do
             :expiration_date => "05/2009"
           },
           :descriptor => {
-            :name => "badcompanyname12*badproduct12",
+            :name => "badcompanyname12*badproductdescription",
             :phone => "%bad4445555",
             :url => "12345678901234"
           },
@@ -2221,8 +2221,8 @@ describe Braintree::Transaction do
         expect(apple_pay_details).not_to be_nil
         expect(apple_pay_details.bin).not_to be_nil
         expect(apple_pay_details.card_type).to eq(Braintree::ApplePayCard::CardType::Visa)
-        expect(apple_pay_details.payment_instrument_name).to eq("Visa 8886")
-        expect(apple_pay_details.source_description).to eq("Visa 8886")
+        expect(apple_pay_details.payment_instrument_name).to match(/\AVisa \d{4}\z/)
+        expect(apple_pay_details.source_description).to match(/\AVisa \d{4}\z/)
         expect(apple_pay_details.expiration_month.to_i).to be > 0
         expect(apple_pay_details.expiration_year.to_i).to be > 0
         expect(apple_pay_details.cardholder_name).not_to be_nil
@@ -2250,8 +2250,8 @@ describe Braintree::Transaction do
         expect(apple_pay_details).not_to be_nil
         expect(apple_pay_details.bin).not_to be_nil
         expect(apple_pay_details.card_type).to eq(Braintree::ApplePayCard::CardType::Visa)
-        expect(apple_pay_details.payment_instrument_name).to eq("Visa 2006")
-        expect(apple_pay_details.source_description).to eq("Visa 2006")
+        expect(apple_pay_details.payment_instrument_name).to match(/\AVisa \d{4}\z/)
+        expect(apple_pay_details.source_description).to match(/\AVisa \d{4}\z/)
         expect(apple_pay_details.expiration_month.to_i).to be > 0
         expect(apple_pay_details.expiration_year.to_i).to be > 0
         expect(apple_pay_details.cardholder_name).not_to be_nil
@@ -2280,8 +2280,8 @@ describe Braintree::Transaction do
         apple_pay_details = result.transaction.apple_pay_details
         expect(apple_pay_details).not_to be_nil
         expect(apple_pay_details.card_type).to eq(Braintree::ApplePayCard::CardType::Visa)
-        expect(apple_pay_details.payment_instrument_name).to eq("Visa 8886")
-        expect(apple_pay_details.source_description).to eq("Visa 8886")
+        expect(apple_pay_details.payment_instrument_name).to match(/\AVisa \d{4}\z/)
+        expect(apple_pay_details.source_description).to match(/\AVisa \d{4}\z/)
         expect(apple_pay_details.expiration_month.to_i).to be > 0
         expect(apple_pay_details.expiration_year.to_i).to be > 0
         expect(apple_pay_details.cardholder_name).not_to be_nil
@@ -2905,6 +2905,106 @@ describe Braintree::Transaction do
         expect(result.transaction.status).to eq(Braintree::Transaction::Status::Authorized)
       end
 
+      it "can create a transaction with a three_d_secure_pass_thru network specified" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009",
+          },
+          :three_d_secure_pass_thru => {
+            :eci_flag => "05",
+            :cavv => "some_cavv",
+            :xid => "some_xid",
+            :three_d_secure_version => "2.2.0",
+            :authentication_response => "Y",
+            :directory_response => "Y",
+            :cavv_algorithm => "2",
+            :network => Braintree::ThreeDSecurePassThru::Network::Visa,
+          },
+        )
+
+        expect(result.success?).to eq(true)
+        expect(result.transaction.status).to eq(Braintree::Transaction::Status::Authorized)
+      end
+
+      it "returns an error for transaction with three_d_secure_pass_thru network when submit_for_settlement is false" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009",
+          },
+          :three_d_secure_pass_thru => {
+            :eci_flag => "05",
+            :cavv => "some_cavv",
+            :xid => "some_xid",
+            :three_d_secure_version => "2.2.0",
+            :authentication_response => "Y",
+            :directory_response => "Y",
+            :cavv_algorithm => "2",
+            :network => Braintree::ThreeDSecurePassThru::Network::Eftpos,
+          },
+          :options => {
+            :submit_for_settlement => false,
+          },
+        )
+
+        expect(result.success?).to eq(false)
+        expect(result.errors.for(:transaction).on(:base)[0].code).to eq(Braintree::ErrorCodes::Transaction::Options::SubmitForSettlementIsNotSupportedForNetwork)
+      end
+
+      it "returns an error for transaction when the three_d_secure_pass_thru network does not support the presentment currency" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :currency_iso_code => "USD",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009",
+          },
+          :three_d_secure_pass_thru => {
+            :eci_flag => "05",
+            :cavv => "some_cavv",
+            :xid => "some_xid",
+            :three_d_secure_version => "2.2.0",
+            :authentication_response => "Y",
+            :directory_response => "Y",
+            :cavv_algorithm => "2",
+            :network => Braintree::ThreeDSecurePassThru::Network::Eftpos,
+          },
+        )
+
+        expect(result.success?).to eq(false)
+        expect(result.errors.for(:transaction).for(:three_d_secure_pass_thru).on(:network)[0].code).to eq(Braintree::ErrorCodes::Transaction::ThreeDSecureNetworkDoesNotSupportCurrency)
+      end
+
+      it "returns an error for transaction when the three_d_secure_pass_thru network does not support the merchant account currency" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009",
+          },
+          :three_d_secure_pass_thru => {
+            :eci_flag => "05",
+            :cavv => "some_cavv",
+            :xid => "some_xid",
+            :three_d_secure_version => "2.2.0",
+            :authentication_response => "Y",
+            :directory_response => "Y",
+            :cavv_algorithm => "2",
+            :network => Braintree::ThreeDSecurePassThru::Network::Eftpos,
+          },
+        )
+
+        expect(result.success?).to eq(false)
+        expect(result.errors.for(:transaction).for(:three_d_secure_pass_thru).on(:network)[0].code).to eq(Braintree::ErrorCodes::Transaction::ThreeDSecureNetworkDoesNotSupportMerchantAccountCurrency)
+      end
+
       it "returns an error for transaction with three_d_secure_pass_thru when processor settings do not support 3DS for card type" do
         result = Braintree::Transaction.create(
           :merchant_account_id => "heartland_ma",
@@ -5908,7 +6008,7 @@ describe Braintree::Transaction do
       end
     end
 
-    xit "Amex Pay with Points" do
+    it "Amex Pay with Points" do
       context "transaction creation" do
         it "succeeds when submit_for_settlement is true" do
           result = Braintree::Transaction.sale(
@@ -6055,7 +6155,7 @@ describe Braintree::Transaction do
     end
 
     context "Pinless debit transaction" do
-      xit "succesfully submits for settlement" do
+      it "successfully submits for settlement" do
         # Flaky test
         result = Braintree::Transaction.sale(
           :amount => Braintree::Test::TransactionAmounts::Authorize,
@@ -6367,7 +6467,7 @@ describe Braintree::Transaction do
       expect(leg_errors).to eq([Braintree::ErrorCodes::Transaction::Industry::Leg::TravelFlight::FareAmountCannotBeNegative])
     end
 
-    xit "succeeds when level 2 data is provided" do
+    it "succeeds when level 2 data is provided" do
       result = Braintree::Transaction.sale(
         :amount => Braintree::Test::TransactionAmounts::Authorize,
         :merchant_account_id => SpecHelper::FakeAmexDirectMerchantAccountId,
@@ -6391,7 +6491,7 @@ describe Braintree::Transaction do
       expect(result.transaction.status).to eq(Braintree::Transaction::Status::SubmittedForSettlement)
     end
 
-    xit "succeeds when level 3 data is provided" do
+    it "succeeds when level 3 data is provided" do
       result = Braintree::Transaction.sale(
         :amount => Braintree::Test::TransactionAmounts::Authorize,
         :merchant_account_id => SpecHelper::FakeAmexDirectMerchantAccountId,
@@ -6532,11 +6632,11 @@ describe Braintree::Transaction do
           expect(result.errors.for(:transaction).on(:amount)[0].code).to eq(Braintree::ErrorCodes::Transaction::SettlementAmountIsTooLarge)
         end
 
-        it "returns an error response when the descriptor is invalid" do
+        it "returns an error response when the descriptor name is too long" do
           result = Braintree::Transaction.update_details(transaction.id, {
             :amount => Braintree::Test::TransactionAmounts::Authorize.to_f - 1,
             :descriptor => {
-              :name => "invalid descriptor name",
+              :name => "invalid descriptor name that is way too long",
               :phone => "invalid phone",
               :url => "12345678901234"
             },

data/spec/integration/braintree/transaction_transfer_type_spec.rb

@@ -16,6 +16,8 @@ describe Braintree::Transaction do
         :transfer => {
           :type => "wallet_transfer",
           :receiver => {
+            :account_reference_number => "test123",
+            :account_reference_number_type => "SOCIAL_NETWORK_PROFILE_ID",
             :first_name => "John",
             :last_name => "Smith",
             :middle_name => "D",
@@ -27,7 +29,8 @@ describe Braintree::Transaction do
             }
           },
           :sender => {
-            :account_reference_number => "123456789",
+            :account_reference_number => "test@example.com",
+            :account_reference_number_type => "EMAIL_ADDRESS",
             :date_of_birth => Date.new(2002, 1, 2),
             :first_name => "Lisa",
             :last_name => "Ray",
@@ -48,6 +51,73 @@ describe Braintree::Transaction do
       expect(result.transaction.status).to eq(Braintree::Transaction::Status::Authorized)
     end
 
+    it "should fail on transaction with invalid sender account reference number type" do
+      transaction_params = {
+        :type => "sale",
+        :amount => "100.00",
+        :merchant_account_id => "aft_first_data_wallet_transfer",
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "06/2026",
+          :cvv => "123"
+        },
+        :transfer => {
+          :type => "wallet_transfer",
+          :sender => {
+            :account_reference_number => "test@example.com",
+            :account_reference_number_type => "INVALID_ACCOUNT_REFERENCE_NUMBER_TYPE",
+            :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)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:account_funding_transaction).first.code).to eq(Braintree::ErrorCodes::Transaction::TransactionTransferSenderAccountReferenceNumberTypeIsInvalid)
+    end
+
+    it "should fail on transaction with invalid receiver account reference number type" do
+      transaction_params = {
+        :type => "sale",
+        :amount => "100.00",
+        :merchant_account_id => "aft_first_data_wallet_transfer",
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "06/2026",
+          :cvv => "123"
+        },
+        :transfer => {
+          :type => "wallet_transfer",
+          :receiver => {
+            :account_reference_number => "test@example.com",
+            :account_reference_number_type => "INVALID_ACCOUNT_REFERENCE_NUMBER_TYPE",
+            :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)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:account_funding_transaction).first.code).to eq(Braintree::ErrorCodes::Transaction::TransactionTransferReceiverAccountReferenceNumberTypeIsInvalid)
+    end
+
     it "should fail on transaction with non brazil merchant" do
       transaction_params = {
         :type => "sale",

data/spec/unit/braintree/address_spec.rb

@@ -58,6 +58,20 @@ describe Braintree::Address do
         Braintree::Address.update("customer_id", "address_id", :street_address => "456 E Main", :invalid_key => "foo")
       end.to raise_error(ArgumentError, "invalid keys: invalid_key")
     end
+
+    it "raises an error if address_id contains invalid characters" do
+      expect do
+        Braintree::Address.update("customer_id", "../../foo", :street_address => "456 E Main")
+      end.to raise_error(ArgumentError, "address_id contains invalid characters")
+    end
+  end
+
+  describe "self.delete" do
+    it "raises an error if address_id contains invalid characters" do
+      expect do
+        Braintree::Address.delete("customer_id", "../../foo")
+      end.to raise_error(ArgumentError, "address_id contains invalid characters")
+    end
   end
 
   describe "self.find" do
@@ -85,6 +99,24 @@ describe Braintree::Address do
         Braintree::Address.find("customer_id", 8675309)
       end.to_not raise_error
     end
+
+    it "raises an error if address_id contains invalid characters" do
+      expect do
+        Braintree::Address.find("customer_id", "../../foo")
+      end.to raise_error(ArgumentError, "address_id contains invalid characters")
+    end
+
+    it "raises an error if address_id is a lone dot segment" do
+      expect do
+        Braintree::Address.find("customer_id", ".")
+      end.to raise_error(ArgumentError, "address_id contains invalid characters")
+    end
+
+    it "raises an error if address_id contains a dot" do
+      expect do
+        Braintree::Address.find("customer_id", "foo.bar")
+      end.to raise_error(ArgumentError, "address_id contains invalid characters")
+    end
   end
 
   describe "self.new" do

data/spec/unit/braintree/credit_card_spec.rb

@@ -51,6 +51,7 @@ describe Braintree::CreditCard do
           :directory_response,
           :cavv_algorithm,
           :ds_transaction_id,
+          :network,
         ]},
         :customer_id,
       ])
@@ -100,6 +101,7 @@ describe Braintree::CreditCard do
           :directory_response,
           :cavv_algorithm,
           :ds_transaction_id,
+          :network,
         ]},
       ])
     end

data/spec/unit/braintree/customer_spec.rb

@@ -164,6 +164,7 @@ describe Braintree::Customer do
             :directory_response,
             :cavv_algorithm,
             :ds_transaction_id,
+            :network,
           ]},
         ]},
         {:paypal_account => [
@@ -307,6 +308,7 @@ describe Braintree::Customer do
             :directory_response,
             :cavv_algorithm,
             :ds_transaction_id,
+            :network,
           ]},
         ]},
         {:tax_identifiers => [

data/spec/unit/braintree/dispute_spec.rb

@@ -278,6 +278,44 @@ describe Braintree::Dispute do
     end
   end
 
+  describe "path traversal" do
+    [
+      :accept,
+      :finalize,
+      :find,
+    ].each do |method_name|
+      it "self.#{method_name} raises an exception if the dispute_id is a traversal segment" do
+        expect do
+          Braintree::Dispute.public_send(method_name, "../../foo")
+        end.to raise_error(ArgumentError, "dispute_id contains invalid characters")
+      end
+    end
+
+    it "self.add_file_evidence raises an exception if the dispute_id is a traversal segment" do
+      expect do
+        Braintree::Dispute.add_file_evidence("../../foo", "document_id")
+      end.to raise_error(ArgumentError, "dispute_id contains invalid characters")
+    end
+
+    it "self.add_text_evidence raises an exception if the dispute_id is a traversal segment" do
+      expect do
+        Braintree::Dispute.add_text_evidence("../../foo", "text evidence")
+      end.to raise_error(ArgumentError, "dispute_id contains invalid characters")
+    end
+
+    it "self.remove_evidence raises an exception if the dispute_id is a traversal segment" do
+      expect do
+        Braintree::Dispute.remove_evidence("../../foo", "evidence_id")
+      end.to raise_error(ArgumentError, "dispute_id contains invalid characters")
+    end
+
+    it "self.remove_evidence raises an exception if the evidence_id is a traversal segment" do
+      expect do
+        Braintree::Dispute.remove_evidence("dispute_id", "../../foo")
+      end.to raise_error(ArgumentError, "evidence_id contains invalid characters")
+    end
+  end
+
   describe "initialize" do
     it "converts string amount_dispute and amount_won" do
       dispute = Braintree::Dispute._new(attributes)

data/spec/unit/braintree/transaction_gateway_spec.rb

@@ -128,6 +128,7 @@ describe Braintree::TransactionGateway do
             :directory_response,
             :cavv_algorithm,
             :ds_transaction_id,
+            :network,
           ]
         },
         {
@@ -135,6 +136,7 @@ describe Braintree::TransactionGateway do
             :type,
             {:sender => [
               :account_reference_number,
+              :account_reference_number_type,
               :date_of_birth,
               :first_name,
               :last_name,
@@ -144,6 +146,7 @@ describe Braintree::TransactionGateway do
             ]},
             {:receiver => [
               :account_reference_number,
+              :account_reference_number_type,
               :first_name,
               :last_name,
               :middle_name,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: braintree
 version: !ruby/object:Gem::Version
-  version: 4.38.0
+  version: 4.40.0
 platform: ruby
 authors:
 - Braintree
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-28 00:00:00.000000000 Z
+date: 2026-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -195,6 +195,7 @@ files:
 - lib/braintree/test_transaction.rb
 - lib/braintree/testing_gateway.rb
 - lib/braintree/three_d_secure_info.rb
+- lib/braintree/three_d_secure_pass_thru.rb
 - lib/braintree/transaction.rb
 - lib/braintree/transaction/address_details.rb
 - lib/braintree/transaction/apple_pay_details.rb