braintree 4.39.0 → 4.40.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a8a4986148f9b2ded5832261519f85d75e2932d7d7d15bc7d49207d2422431e
-  data.tar.gz: 3431f5d87f5f15ffd7c2d29fe28674d7c49645f0447342360d0f41444def6c16
+  metadata.gz: a358a5cff7db74d5364a662ed1076dd786742d6d6f75b0f9c040fda06353a955
+  data.tar.gz: b78e2a6f20ab1207515ea76f3e7aaa6a367283b10821b026c9f89498e2e8f35c
 SHA512:
-  metadata.gz: d523c2199f88f2eea71960c92659b7e8aabb02aa78c35ab51f0b513b575d408b6df9b881c5d895ed8a30b300c3ab4c43fa48ce3d88a331dcd9c96c9c6aac8ca8
-  data.tar.gz: d6dc3e11eec83fcbd5c045ff92b04e83ff80686ecc19eedf17a50b19b68d0511f2ec1514fa0f13081ba889509ae161f8f1121380a6e51baa1daf66fa6115f509
+  metadata.gz: 7fbb0b0ca10ec35cd3e8e6d34476eaada51e465caf4aa25a00e6d61fdbafea147a25579ed012717f2b2fec3da184d823dd0756add7738d8e4bcf1a8abea1dd2d
+  data.tar.gz: 7374cd696e006db551149f9363194c3a8ecafc7ec607b93b6a53f2eeb3eb2961e4b63bd68d20c2ea0f5262fab405597e924219b7e76fd514b0a398c367fa7403

data/lib/braintree/address_gateway.rb

@@ -13,7 +13,7 @@ module Braintree
       unless attributes[:customer_id]
         raise ArgumentError, "Expected hash to contain a :customer_id"
       end
-      unless attributes[:customer_id] =~ /\A[0-9A-Za-z_-]+\z/
+      if Util.invalid_path_segment?(attributes[:customer_id])
         raise ArgumentError, ":customer_id contains invalid characters"
       end
       response = @config.http.post("#{@config.base_merchant_path}/customers/#{attributes.delete(:customer_id)}/addresses", :address => attributes)
@@ -32,13 +32,14 @@ module Braintree
 
     def delete(customer_or_customer_id, address_id)
       customer_id = _determine_customer_id(customer_or_customer_id)
+      address_id = _determine_address_id(address_id)
       @config.http.delete("#{@config.base_merchant_path}/customers/#{customer_id}/addresses/#{address_id}")
       SuccessfulResult.new
     end
 
     def find(customer_or_customer_id, address_id)
       customer_id = _determine_customer_id(customer_or_customer_id)
-      raise ArgumentError if address_id.nil? || address_id.to_s.strip == ""
+      address_id = _determine_address_id(address_id)
       response = @config.http.get("#{@config.base_merchant_path}/customers/#{customer_id}/addresses/#{address_id}")
       Address._new(@gateway, response[:address])
     rescue NotFoundError
@@ -48,6 +49,7 @@ module Braintree
     def update(customer_or_customer_id, address_id, attributes)
       Util.verify_keys(AddressGateway._update_signature, attributes)
       customer_id = _determine_customer_id(customer_or_customer_id)
+      address_id = _determine_address_id(address_id)
       response = @config.http.put("#{@config.base_merchant_path}/customers/#{customer_id}/addresses/#{address_id}", :address => attributes)
       if response[:address]
         SuccessfulResult.new(:address => Address._new(@gateway, response[:address]))
@@ -64,12 +66,20 @@ module Braintree
 
     def _determine_customer_id(customer_or_customer_id)
       customer_id = customer_or_customer_id.is_a?(Customer) ? customer_or_customer_id.id : customer_or_customer_id
-      unless customer_id =~ /\A[\w_-]+\z/
+      if Util.invalid_path_segment?(customer_id)
         raise ArgumentError, "customer_id contains invalid characters"
       end
       customer_id
     end
 
+    def _determine_address_id(address_id)
+      address_id = address_id.to_s
+      if Util.invalid_path_segment?(address_id)
+        raise ArgumentError, "address_id contains invalid characters"
+      end
+      address_id
+    end
+
     def self._create_signature
       _shared_signature + [:customer_id]
     end

data/lib/braintree/credit_card_gateway.rb

@@ -129,6 +129,7 @@ module Braintree
           :directory_response,
           :cavv_algorithm,
           :ds_transaction_id,
+          :network,
         ]
       }
 

data/lib/braintree/credit_card_verification_gateway.rb

@@ -81,6 +81,7 @@ module Braintree
           :directory_response,
           :ds_transaction_id,
           :eci_flag,
+          :network,
           :three_d_secure_version,
           :xid,
         ]},

data/lib/braintree/dispute_gateway.rb

@@ -7,7 +7,7 @@ module Braintree
     end
 
     def accept(dispute_id)
-      raise ArgumentError, "dispute_id contains invalid characters" unless dispute_id.to_s =~ /\A[\w-]+\z/
+      raise ArgumentError, "dispute_id contains invalid characters" if Util.invalid_path_segment?(dispute_id)
       raise ArgumentError, "dispute_id cannot be blank" if dispute_id.nil? || dispute_id.to_s.strip == ""
 
       response = @config.http.put("#{@config.base_merchant_path}/disputes/#{dispute_id}/accept")
@@ -21,7 +21,7 @@ module Braintree
     end
 
     def add_file_evidence(dispute_id, document_id_or_request)
-      raise ArgumentError, "dispute_id contains invalid characters" unless dispute_id.to_s =~ /\A[\w-]+\z/
+      raise ArgumentError, "dispute_id contains invalid characters" if Util.invalid_path_segment?(dispute_id)
       raise ArgumentError, "dispute_id cannot be blank" if dispute_id.nil? || dispute_id.to_s.strip == ""
       raise ArgumentError, "document_id_or_request cannot be blank" if document_id_or_request.nil?
 
@@ -51,7 +51,7 @@ module Braintree
     end
 
     def add_text_evidence(dispute_id, content_or_request)
-      raise ArgumentError, "dispute_id contains invalid characters" unless dispute_id.to_s =~ /\A[\w-]+\z/
+      raise ArgumentError, "dispute_id contains invalid characters" if Util.invalid_path_segment?(dispute_id)
       raise ArgumentError, "dispute_id cannot be blank" if dispute_id.nil? || dispute_id.to_s.strip == ""
       raise ArgumentError, "content_or_request cannot be blank" if content_or_request.nil?
 
@@ -84,7 +84,7 @@ module Braintree
     end
 
     def finalize(dispute_id)
-      raise ArgumentError, "dispute_id contains invalid characters" unless dispute_id.to_s =~ /\A[\w-]+\z/
+      raise ArgumentError, "dispute_id contains invalid characters" if Util.invalid_path_segment?(dispute_id)
       raise ArgumentError, "dispute_id cannot be blank" if dispute_id.nil? || dispute_id.to_s.strip == ""
 
       response = @config.http.put("#{@config.base_merchant_path}/disputes/#{dispute_id}/finalize")
@@ -98,7 +98,7 @@ module Braintree
     end
 
     def find(dispute_id)
-      raise ArgumentError, "dispute_id contains invalid characters" unless dispute_id.to_s =~ /\A[\w-]+\z/
+      raise ArgumentError, "dispute_id contains invalid characters" if Util.invalid_path_segment?(dispute_id)
       raise ArgumentError, "dispute_id cannot be blank" if dispute_id.nil? || dispute_id.to_s.strip == ""
       response = @config.http.get("#{@config.base_merchant_path}/disputes/#{dispute_id}")
       Dispute._new(response[:dispute])
@@ -107,9 +107,9 @@ module Braintree
     end
 
     def remove_evidence(dispute_id, evidence_id)
-      raise ArgumentError, "dispute_id contains invalid characters" unless dispute_id.to_s =~ /\A[\w-]+\z/
+      raise ArgumentError, "dispute_id contains invalid characters" if Util.invalid_path_segment?(dispute_id)
       raise ArgumentError, "dispute_id cannot be blank" if dispute_id.nil? || dispute_id.to_s.strip == ""
-      raise ArgumentError, "evidence_id contains invalid characters" unless evidence_id.to_s =~ /\A[\w-]+\z/
+      raise ArgumentError, "evidence_id contains invalid characters" if Util.invalid_path_segment?(evidence_id)
       raise ArgumentError, "evidence_id cannot be blank" if evidence_id.nil? || evidence_id.to_s.strip == ""
 
       response = @config.http.delete("#{@config.base_merchant_path}/disputes/#{dispute_id}/evidence/#{evidence_id}")

data/lib/braintree/error_codes.rb

@@ -216,6 +216,8 @@ module Braintree
       CannotVaultOneTimeUsePayPalAccount = "82902"
       ConsentCodeOrAccessTokenIsRequired = "82901"
       CustomerIdIsRequiredForVaulting = "82905"
+      EmailFormatIsInvalid = "92963"
+      EmailIsTooLong = "92964"
       IncompletePayPalAccount = "82901"
       InvalidFundingSourceSelection = "92913"
       InvalidParamsForPayPalAccountUpdate = "92915"
@@ -472,6 +474,10 @@ module Braintree
       ThreeDSecureEciFlagIsInvalid = "915114"
       ThreeDSecureEciFlagIsRequired = "915113"
       ThreeDSecureMerchantAccountDoesNotSupportCardType = "915131"
+      ThreeDSecureNetworkDoesNotMatchPaymentInstrument = "915139"
+      ThreeDSecureNetworkDoesNotSupportCurrency = "915239"
+      ThreeDSecureNetworkDoesNotSupportMerchantAccountCurrency = "915243"
+      ThreeDSecureNetworkIsInvalid = "915128"
       ThreeDSecureThreeDSecureVersionIsInvalid = "915119"
       ThreeDSecureTokenIsInvalid = "91568"
       ThreeDSecureTransactionDataDoesntMatchVerify = "91570"
@@ -502,6 +508,7 @@ module Braintree
 
 
       module Options
+        SubmitForSettlementIsNotSupportedForNetwork = "915261"
         SubmitForSettlementIsRequiredForCloning = "91544"
         SubmitForSettlementIsRequiredForPayPalUnilateral = "91582"
         VaultIsDisabled = "91525"
@@ -768,6 +775,10 @@ module Braintree
         DirectoryResponseIsInvalid = "942121"
         EciFlagIsInvalid = "942114"
         EciFlagIsRequired = "942113"
+        NetworkDoesNotMatchPaymentInstrument = "942139"
+        NetworkDoesNotSupportCurrency = "942129"
+        NetworkDoesNotSupportMerchantAccountCurrency = "942130"
+        NetworkIsInvalid = "942128"
         ThreeDSecureVersionIsInvalid = "942119"
         ThreeDSecureVersionIsRequired = "942117"
       end

data/lib/braintree/payment_method_gateway.rb

@@ -199,6 +199,7 @@ module Braintree
           :directory_response,
           :cavv_algorithm,
           :ds_transaction_id,
+          :network,
         ]
       }
       signature << {

data/lib/braintree/three_d_secure_pass_thru.rb

@@ -0,0 +1,11 @@
+module Braintree
+  module ThreeDSecurePassThru
+    module Network
+      Eftpos = "eftpos"
+      MasterCard = "Mastercard"
+      Visa = "Visa"
+
+      All = constants.map { |c| const_get(c) }
+    end
+  end
+end

data/lib/braintree/transaction_gateway.rb

@@ -283,6 +283,7 @@ module Braintree
             :directory_response,
             :cavv_algorithm,
             :ds_transaction_id,
+            :network,
           ]
         },
         {

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 = 40
     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/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,

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