braintree 4.39.0 → 4.41.0

data/lib/braintree/transaction_search.rb

@@ -46,6 +46,7 @@ module Braintree
     equality_fields :credit_card_expiration_date
     partial_match_fields :credit_card_number
 
+    multiple_value_field :ach_type, :allows => Transaction::AchType::All
     multiple_value_field :created_using, :allows => [
       Transaction::CreatedUsing::FullInformation,
       Transaction::CreatedUsing::Token

data/lib/braintree/us_bank_account_gateway.rb

@@ -8,6 +8,8 @@ module Braintree
 
     def find(token)
       raise ArgumentError if token.nil? || token.to_s.strip == ""
+      raise ArgumentError, "token contains invalid characters" if Util.invalid_path_segment?(token)
+
       response = @config.http.get("#{@config.base_merchant_path}/payment_methods/us_bank_account/#{token}")
       UsBankAccount._new(@gateway, response[:us_bank_account])
     rescue NotFoundError

data/lib/braintree/us_bank_account_verification_gateway.rb

@@ -8,6 +8,8 @@ module Braintree
 
     def confirm_micro_transfer_amounts(id, deposit_amounts)
       raise ArgumentError if id.nil? || id.to_s.strip == "" || !deposit_amounts.kind_of?(Array)
+      raise ArgumentError, "id contains invalid characters" if Util.invalid_path_segment?(id)
+
       response = @config.http.put(
         "#{@config.base_merchant_path}/us_bank_account_verifications/#{id}/confirm_micro_transfer_amounts",
         :us_bank_account_verification => {
@@ -27,6 +29,8 @@ module Braintree
 
     def find(id)
       raise ArgumentError if id.nil? || id.to_s.strip == ""
+      raise ArgumentError, "id contains invalid characters" if Util.invalid_path_segment?(id)
+
       response = @config.http.get("#{@config.base_merchant_path}/us_bank_account_verifications/#{id}")
       UsBankAccountVerification._new(response[:us_bank_account_verification])
     rescue NotFoundError

data/lib/braintree/util.rb

@@ -1,5 +1,10 @@
 module Braintree
   module Util
+    # Allowlist of the characters that make up a Braintree id/token.
+    def self.invalid_path_segment?(value)
+      !value.to_s.match?(/\A[A-Za-z0-9_-]+\z/)
+    end
+
     def self.extract_attribute_as_array(hash, attribute)
       raise UnexpectedError.new("Unprocessable entity due to an invalid request") if hash.nil?
       value = hash.has_key?(attribute) ? hash.delete(attribute) : []

data/lib/braintree/version.rb

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

data/lib/braintree.rb

@@ -138,6 +138,7 @@ require "braintree/risk_data/liability_shift"
 require "braintree/facilitated_details"
 require "braintree/facilitator_details"
 require "braintree/three_d_secure_info"
+require "braintree/three_d_secure_pass_thru"
 require "braintree/settlement_batch_summary"
 require "braintree/settlement_batch_summary_gateway"
 require "braintree/resource_collection"

data/spec/integration/braintree/advanced_search_spec.rb

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

data/spec/integration/braintree/braintree_gateway_spec.rb

@@ -12,8 +12,7 @@ describe Braintree::Gateway do
   end
 
   describe "query" do
-    # we are temporarily skipping this test until we have a more stable CI env
-    xit "makes valid GraphQL queries when given a definition" do
+    it "makes valid GraphQL mutation queries for tokenizeCreditCard" do
       definition = <<-GRAPHQL
       mutation ExampleServerSideSingleUseToken($input: TokenizeCreditCardInput!) {
         tokenizeCreditCard(input: $input) {

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

@@ -378,6 +378,20 @@ describe Braintree::ClientToken do
       end
     end
 
+    it "can pass preferred_payment_method_token" do
+      result = Braintree::Customer.create
+      raw_client_token = Braintree::ClientToken.generate(
+        :customer_id => result.customer.id,
+        :preferred_payment_method_token => "a-pmt",
+      )
+      client_token = decode_client_token(raw_client_token)
+
+      expect(client_token["paymentMethodIdJwt"]).not_to be_nil
+      jwt_segment = client_token["paymentMethodIdJwt"].split(".")[1]
+      jwt_payload = JSON.parse(Base64.urlsafe_decode64(jwt_segment + "=" * ((4 - jwt_segment.length % 4) % 4)))
+      expect(jwt_payload["pmid"]).to eq("a-pmt")
+    end
+
     it "can pass merchant_account_id" do
       merchant_account_id = SpecHelper::NonDefaultMerchantAccountId
 

data/spec/integration/braintree/credit_card_spec.rb

@@ -312,6 +312,99 @@ describe Braintree::CreditCard do
       expect(result.success?).to eq(true)
     end
 
+    it "accepts a three_d_secure_pass_thru network specified in the request" do
+      customer = Braintree::Customer.create!
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::TransactableVisa,
+        :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",
+          :ds_transaction_id => "some_ds_transaction_id",
+          :network => Braintree::ThreeDSecurePassThru::Network::Visa,
+        },
+        :options => {:verify_card => true},
+      )
+      expect(result.success?).to eq(true)
+    end
+
+    it "rejects invalid network value in 3ds pass thru params" do
+      customer = Braintree::Customer.create!
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+        :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",
+          :ds_transaction_id => "some_ds_transaction_id",
+          :network => "DISCOVER",
+        },
+        :options => {:verify_card => true},
+      )
+      expect(result).not_to be_success
+      error = result.errors.for(:verification).first
+      expect(error.code).to eq(Braintree::ErrorCodes::Verification::ThreeDSecurePassThru::NetworkIsInvalid)
+      expect(error.message).to eq("Network is invalid. Supported networks are eftpos, Visa, and Mastercard.")
+    end
+
+    it "rejects request where 3ds pass thru network does not match the payment instrument (VISA nonce, Mastercard network)" do
+      customer = Braintree::Customer.create!
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::TransactableVisa,
+        :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",
+          :ds_transaction_id => "some_ds_transaction_id",
+          :network => Braintree::ThreeDSecurePassThru::Network::MasterCard,
+        },
+        :options => {:verify_card => true},
+      )
+      expect(result).not_to be_success
+      error = result.errors.for(:verification).first
+      expect(error.code).to eq(Braintree::ErrorCodes::Verification::ThreeDSecurePassThru::NetworkDoesNotMatchPaymentInstrument)
+      expect(error.message).to eq("Network does not match the payment instrument.")
+    end
+
+    it "rejects request where 3ds pass thru network does not support the merchant account currency" do
+      customer = Braintree::Customer.create!
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::TransactableVisa,
+        :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",
+          :ds_transaction_id => "some_ds_transaction_id",
+          :network => Braintree::ThreeDSecurePassThru::Network::Eftpos,
+        },
+        :options => {:verify_card => true},
+      )
+      expect(result).not_to be_success
+      error = result.errors.for(:verification).first
+      expect(error.code).to eq(Braintree::ErrorCodes::Verification::ThreeDSecurePassThru::NetworkDoesNotSupportMerchantAccountCurrency)
+      expect(error.message).to eq("Network does not support the currency of the merchant account.")
+    end
+
     it "returns 3DS info on cc verification" do
       customer = Braintree::Customer.create!
       result = Braintree::CreditCard.create(
@@ -1263,8 +1356,7 @@ describe Braintree::CreditCard do
   end
 
   describe "self.expiring_between" do
-    #Disabling this test until we have a more stable CI
-    xit "finds payment methods expiring between the given dates" do
+    it "finds payment methods expiring between the given dates" do
       next_year = Time.now.year + 1
       collection = Braintree::CreditCard.expiring_between(Time.mktime(next_year, 1), Time.mktime(next_year, 12))
       expect(collection.maximum_size).to be > 0

data/spec/integration/braintree/credit_card_verification_spec.rb

@@ -630,5 +630,38 @@ describe Braintree::CreditCardVerification, "search" do
       expect(result.credit_card_verification.processor_response_type).to eq(Braintree::ProcessorResponseTypes::Approved)
       expect(result.credit_card_verification.network_transaction_id).not_to be_nil
     end
+
+    it "can create a verification with a three_d_secure_pass_thru network specified" do
+      verification_params = {
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "12/12",
+        },
+        :options => {
+          :amount => "10.00",
+        },
+        :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",
+          :ds_transaction_id => "some_ds_id",
+          :network => Braintree::ThreeDSecurePassThru::Network::Visa,
+        },
+      }
+
+      result = Braintree::CreditCardVerification.create(verification_params)
+
+      expect(result).to be_success
+      expect(result.credit_card_verification.id).to match(/^\w{6,}$/)
+      expect(result.credit_card_verification.status).to eq(Braintree::CreditCardVerification::Status::Verified)
+      expect(result.credit_card_verification.processor_response_code).to eq("1000")
+      expect(result.credit_card_verification.processor_response_text).to eq("Approved")
+      expect(result.credit_card_verification.processor_response_type).to eq(Braintree::ProcessorResponseTypes::Approved)
+      expect(result.credit_card_verification.network_transaction_id).not_to be_nil
+    end
   end
 end

data/spec/integration/braintree/customer_spec.rb

@@ -4,8 +4,7 @@ require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
 
 describe Braintree::Customer do
   describe "self.all" do
-    #Disabling test until we have a more stable CI
-    xit "gets more than a page of customers" do
+    it "gets more than a page of customers" do
       customers = Braintree::Customer.all
       expect(customers.maximum_size).to be > 100
 
@@ -1242,7 +1241,7 @@ describe Braintree::Customer do
       expect(apple_pay_card.expiration_year).not_to be_nil
       expect(apple_pay_card.healthcare).not_to be_nil
       expect(apple_pay_card.issuing_bank).not_to be_nil
-      expect(apple_pay_card.payment_instrument_name).to eq("AmEx 41002")
+      expect(apple_pay_card.payment_instrument_name).to match(/\AAmEx \d{4,5}\z/)
       expect(apple_pay_card.payroll).not_to be_nil
       expect(apple_pay_card.prepaid).not_to be_nil
       expect(apple_pay_card.prepaid_reloadable).not_to be_nil
@@ -1326,7 +1325,7 @@ describe Braintree::Customer do
       expect(venmo_account.username).not_to be_nil
     end
 
-    xit "returns associated us bank accounts" do
+    it "returns associated us bank accounts" do
       result = Braintree::Customer.create(
         :payment_method_nonce => generate_non_plaid_us_bank_account_nonce,
         :credit_card => {
@@ -1693,7 +1692,8 @@ describe Braintree::Customer do
 
       apple_pay_card = result.customer.payment_methods.find { |pm| pm.is_a?(Braintree::ApplePayCard) }
       expect(apple_pay_card).not_to be_nil
-      expect(apple_pay_card.last_4).to eq(Braintree::Test::CreditCardNumbers::Visa[-4..-1])
+      expect(apple_pay_card.card_type).to eq(Braintree::ApplePayCard::CardType::Visa)
+      expect(apple_pay_card.last_4).to match(/\A\d{4}\z/)
       expect(apple_pay_card.cardholder_name).to eq("Updated Joe Cardholder")
 
       verification = apple_pay_card.verification
@@ -2084,6 +2084,154 @@ describe Braintree::Customer do
       expect(result).to be_success
     end
 
+    it "accepts a three_d_secure_pass_thru network specified on customer create" do
+      result = Braintree::Customer.create(
+        :payment_method_nonce => Braintree::Test::Nonce::TransactableVisa,
+        :credit_card => {
+          :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",
+            :ds_transaction_id => "some_ds_transaction_id",
+            :network => Braintree::ThreeDSecurePassThru::Network::Visa,
+          },
+          :options => {:verify_card => true},
+        },
+      )
+      expect(result).to be_success
+    end
+
+    it "rejects invalid network value in 3ds pass thru params on customer create" do
+      result = Braintree::Customer.create(
+        :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+        :credit_card => {
+          :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",
+            :ds_transaction_id => "some_ds_transaction_id",
+            :network => "DISCOVER",
+          },
+          :options => {:verify_card => true},
+        },
+      )
+      expect(result).not_to be_success
+      error = result.errors.for(:verification).first
+      expect(error.code).to eq(Braintree::ErrorCodes::Verification::ThreeDSecurePassThru::NetworkIsInvalid)
+      expect(error.message).to eq("Network is invalid. Supported networks are eftpos, Visa, and Mastercard.")
+    end
+
+    it "rejects request where 3ds pass thru network does not match the payment instrument on customer create (VISA nonce, Mastercard network)" do
+      result = Braintree::Customer.create(
+        :payment_method_nonce => Braintree::Test::Nonce::TransactableVisa,
+        :credit_card => {
+          :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",
+            :ds_transaction_id => "some_ds_transaction_id",
+            :network => Braintree::ThreeDSecurePassThru::Network::MasterCard,
+          },
+          :options => {:verify_card => true},
+        },
+      )
+      expect(result).not_to be_success
+      error = result.errors.for(:verification).first
+      expect(error.code).to eq(Braintree::ErrorCodes::Verification::ThreeDSecurePassThru::NetworkDoesNotMatchPaymentInstrument)
+      expect(error.message).to eq("Network does not match the payment instrument.")
+    end
+
+    it "accepts a three_d_secure_pass_thru network specified on customer update" do
+      customer = Braintree::Customer.create!
+      result = Braintree::Customer.update(
+        customer.id,
+        :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",
+            :ds_transaction_id => "some_ds_transaction_id",
+            :network => Braintree::ThreeDSecurePassThru::Network::Visa,
+          },
+          :options => {:verify_card => true}
+        },
+      )
+
+      expect(result).to be_success
+    end
+
+    it "rejects invalid network value in 3ds pass thru params on customer update" do
+      customer = Braintree::Customer.create!
+      result = Braintree::Customer.update(
+        customer.id,
+        :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",
+            :ds_transaction_id => "some_ds_transaction_id",
+            :network => "DISCOVER",
+          },
+          :options => {:verify_card => true}
+        },
+      )
+      expect(result).not_to be_success
+      error = result.errors.for(:verification).first
+      expect(error.code).to eq(Braintree::ErrorCodes::Verification::ThreeDSecurePassThru::NetworkIsInvalid)
+      expect(error.message).to eq("Network is invalid. Supported networks are eftpos, Visa, and Mastercard.")
+    end
+
+    it "rejects request where 3ds pass thru network does not match the payment instrument on customer update (VISA card, Mastercard network)" do
+      customer = Braintree::Customer.create!
+      result = Braintree::Customer.update(
+        customer.id,
+        :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",
+            :ds_transaction_id => "some_ds_transaction_id",
+            :network => Braintree::ThreeDSecurePassThru::Network::MasterCard,
+          },
+          :options => {:verify_card => true}
+        },
+      )
+      expect(result).not_to be_success
+      error = result.errors.for(:verification).first
+      expect(error.code).to eq(Braintree::ErrorCodes::Verification::ThreeDSecurePassThru::NetworkDoesNotMatchPaymentInstrument)
+      expect(error.message).to eq("Network does not match the payment instrument.")
+    end
+
     it "returns 3DS info on cc verification" do
       result = Braintree::Customer.create(
         :payment_method_nonce => Braintree::Test::Nonce::ThreeDSecureVisaFullAuthentication,
@@ -2529,4 +2677,47 @@ describe Braintree::Customer do
     end
   end
 
+  describe "path traversal" do
+    it "self.update rejects a traversal customer_id and does not void the victim transaction" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+        :options => {:submit_for_settlement => false},
+      )
+      traversal_id = "../transactions/#{transaction.id}/void"
+
+      expect do
+        Braintree::Customer.update(traversal_id, :first_name => "HackerOne")
+      end.to raise_error(ArgumentError, "customer_id contains invalid characters")
+
+      unaffected_transaction = Braintree::Transaction.find(transaction.id)
+      expect(unaffected_transaction.status).to eq(Braintree::Transaction::Status::Authorized)
+    end
+
+    it "self.delete rejects a traversal customer_id and does not delete the victim payment method" do
+      create_result = Braintree::Customer.create(:first_name => "Victim")
+      expect(create_result.success?).to eq(true)
+      customer = create_result.customer
+
+      credit_card_result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::Visa,
+        :expiration_date => "05/2009",
+      )
+      expect(credit_card_result.success?).to eq(true)
+      token = credit_card_result.credit_card.token
+      traversal_id = "../payment_methods/any/#{token}"
+
+      expect do
+        Braintree::Customer.delete(traversal_id)
+      end.to raise_error(ArgumentError, "customer_id contains invalid characters")
+
+      unaffected_credit_card = Braintree::CreditCard.find(token)
+      expect(unaffected_credit_card.token).to eq(token)
+    end
+  end
+
 end

data/spec/integration/braintree/http_spec.rb

@@ -97,7 +97,7 @@ describe Braintree::Http do
     end
 
     describe "ssl_version" do
-      xit "causes failed requests to sandbox with incompatible SSL version" do
+      it "causes failed requests to sandbox with incompatible SSL version" do
         begin
           original_env = Braintree::Configuration.environment
           Braintree::Configuration.environment = :sandbox

data/spec/integration/braintree/payment_method_spec.rb

@@ -92,8 +92,8 @@ describe Braintree::PaymentMethod do
       expect(apple_pay_card.bin).not_to be_nil
       expect(apple_pay_card.token).to eq(token)
       expect(apple_pay_card.card_type).to eq(Braintree::ApplePayCard::CardType::AmEx)
-      expect(apple_pay_card.payment_instrument_name).to eq("AmEx 41002")
-      expect(apple_pay_card.source_description).to eq("AmEx 41002")
+      expect(apple_pay_card.payment_instrument_name).to match(/\AAmEx \d{4,5}\z/)
+      expect(apple_pay_card.source_description).to match(/\AAmEx \d{4,5}\z/)
       expect(apple_pay_card.default).to eq(true)
       expect(apple_pay_card.image_url).to match(/apple_pay/)
       expect(apple_pay_card.expiration_month.to_i).to be > 0
@@ -127,8 +127,8 @@ describe Braintree::PaymentMethod do
       expect(apple_pay_card.bin).not_to be_nil
       expect(apple_pay_card.token).to eq(token)
       expect(apple_pay_card.card_type).to eq(Braintree::ApplePayCard::CardType::Visa)
-      expect(apple_pay_card.payment_instrument_name).to eq("Visa 2006")
-      expect(apple_pay_card.source_description).to eq("Visa 2006")
+      expect(apple_pay_card.payment_instrument_name).to match(/\AVisa \d{4}\z/)
+      expect(apple_pay_card.source_description).to match(/\AVisa \d{4}\z/)
       expect(apple_pay_card.default).to eq(true)
       expect(apple_pay_card.image_url).to match(/apple_pay/)
       expect(apple_pay_card.expiration_month.to_i).to be > 0
@@ -382,6 +382,76 @@ describe Braintree::PaymentMethod do
       expect(result).to be_success
     end
 
+    it "accepts a three_d_secure_pass_thru network specified in the request" do
+      customer = Braintree::Customer.create!
+      result = Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::TransactableVisa,
+        :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",
+          :ds_transaction_id => "some_ds_transaction_id",
+          :network => Braintree::ThreeDSecurePassThru::Network::Visa,
+        },
+        :options => {:verify_card => true},
+      )
+
+      expect(result).to be_success
+    end
+
+    it "rejects invalid network value in 3ds pass thru params" do
+      customer = Braintree::Customer.create!
+      result = Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+        :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",
+          :ds_transaction_id => "some_ds_transaction_id",
+          :network => "DISCOVER",
+        },
+        :options => {:verify_card => true},
+      )
+      expect(result).not_to be_success
+      error = result.errors.for(:verification).first
+      expect(error.code).to eq(Braintree::ErrorCodes::Verification::ThreeDSecurePassThru::NetworkIsInvalid)
+      expect(error.message).to eq("Network is invalid. Supported networks are eftpos, Visa, and Mastercard.")
+    end
+
+    it "rejects request where 3ds pass thru network does not match the payment instrument (VISA nonce, Mastercard network)" do
+      customer = Braintree::Customer.create!
+      result = Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::TransactableVisa,
+        :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",
+          :ds_transaction_id => "some_ds_transaction_id",
+          :network => Braintree::ThreeDSecurePassThru::Network::MasterCard,
+        },
+        :options => {:verify_card => true},
+      )
+      expect(result).not_to be_success
+      error = result.errors.for(:verification).first
+      expect(error.code).to eq(Braintree::ErrorCodes::Verification::ThreeDSecurePassThru::NetworkDoesNotMatchPaymentInstrument)
+      expect(error.message).to eq("Network does not match the payment instrument.")
+    end
+
     it "returns 3DS info on cc verification" do
       customer = Braintree::Customer.create.customer
       result = Braintree::PaymentMethod.create(
@@ -813,7 +883,7 @@ describe Braintree::PaymentMethod do
         expect(update_result.payment_method.verification.credit_card[:account_type]).to eq("credit")
       end
 
-      xit "updates the credit card with account_type debit" do
+      it "updates the credit card with account_type debit" do
         customer = Braintree::Customer.create!
         credit_card = Braintree::CreditCard.create!(
           :cardholder_name => "Original Holder",
@@ -1404,7 +1474,7 @@ describe Braintree::PaymentMethod do
         expect(apple_pay_card.image_url).to match(/apple_pay/)
         expect(apple_pay_card.expiration_month.to_i).to be > 0
         expect(apple_pay_card.expiration_year.to_i).to be > 0
-        expect(apple_pay_card.source_description).to eq("AmEx 41002")
+        expect(apple_pay_card.source_description).to match(/\AAmEx \d{4,5}\z/)
         expect(apple_pay_card.customer_id).to eq(customer.id)
       end
 
@@ -1427,7 +1497,7 @@ describe Braintree::PaymentMethod do
         expect(apple_pay_card.image_url).to match(/apple_pay/)
         expect(apple_pay_card.expiration_month.to_i).to be > 0
         expect(apple_pay_card.expiration_year.to_i).to be > 0
-        expect(apple_pay_card.source_description).to eq("Visa 2006")
+        expect(apple_pay_card.source_description).to match(/\AVisa \d{4}\z/)
         expect(apple_pay_card.customer_id).to eq(customer.id)
         expect(apple_pay_card.is_device_token).to eq(false)
         apple_pay_card.merchant_token_identifier == "DNITHE302308980427388297"