braintree 2.96.0 → 2.97.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05a36d5ea5b0870293e17db6baa85393f97e0a8aa8ba495ee34ec2f30d64f29a
-  data.tar.gz: d7291802e13bfdecf5e3258b0f9cac7bb15654fd4f6249faf0e96444de55576e
+  metadata.gz: b9796b601bd0eb88d43af1f1f4649dbef92b3f13b64e2ba1530ce2fe184b3817
+  data.tar.gz: baf2344bb18263a50a0e6106918239a5c61f3879e003e8cb8a5f771e949f6089
 SHA512:
-  metadata.gz: d5bee8dcbe48df9d0c752d150dd3c18ae3c4232a31aa3e850ac5ab1a8ef4a85f292515b96489dbf736a2bde1d4780bb1f5f1edfb4eeaeacde6b983e8c72d4825
-  data.tar.gz: 5065e4ad5cde4db02b5bfdee866425a8d837604ff50b69d4c1f721915e6483cec41ef8ff9e53f03c3ce2290d1e27f13a346c01bb9a277ffd0b179284ed4fba9d
+  metadata.gz: 295157174583b40728788a3ff63530e90bec65095500ce23666a582a8c61ddd1d036f906ff5b40f1d3419b656f3bd7830cd877aad65c89b5eb1ded0ce77fe404
+  data.tar.gz: 18895f9963e28778251ecf5850dc039d54c5b7bc85fa8f1c548c7f9990ae1e6cc5d5394e56b8bbbdeb491c71387311dc285ed997011ed6572fc65d1cd5cf0b58

data/lib/braintree/credit_card_gateway.rb

@@ -108,7 +108,7 @@ module Braintree
 
     def self._signature(type) # :nodoc:
       billing_address_params = AddressGateway._shared_signature
-      options = [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method]
+      options = [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type]
       signature = [
         :billing_address_id, :cardholder_name, :cvv, :device_session_id, :expiration_date,
         :expiration_month, :expiration_year, :number, :token, :venmo_sdk_payment_method_code,

data/lib/braintree/error_codes.rb

@@ -24,6 +24,7 @@ module Braintree
       PostalCodeInvalidCharacters = "81813"
       PostalCodeIsInvalid = "91826"
       PostalCodeIsRequired = "81808"
+      PostalCodeIsRequiredForCardBrandAndProcessor = "81828"
       PostalCodeIsTooLong = "81809"
       RegionIsInvalid = "91825"
       RegionIsTooLong = "81810"
@@ -407,6 +408,10 @@ module Braintree
       ThreeDSecureCavvIsRequired = "915116"
       ThreeDSecureXidIsRequired = "915115"
       ThreeDSecureEciFlagIsInvalid = "915114"
+      ThreeDSecureThreeDSecureVersionIsInvalid = "915119"
+      ThreeDSecureAuthenticationResponseIsInvalid = "915120"
+      ThreeDSecureDirectoryResponseIsInvalid = "915121"
+      ThreeDSecureCavvAlgorithmIsInvalid = "915122"
       ThreeDSecureMerchantAccountDoesNotSupportCardType = "915131"
       TypeIsInvalid = "91523"
       TypeIsRequired = "91524"
@@ -439,6 +444,16 @@ module Braintree
           CheckOutDateIsInvalid = "93405"
           CheckOutDateMustFollowCheckInDate = "93406"
           UnknownDataField = "93407"
+          RoomRateMustBeGreaterThanZero = "93433"
+          RoomRateFormatIsInvalid = "93434"
+          RoomRateIsTooLarge = "93435"
+          RoomTaxMustBeGreaterThanZero = "93436"
+          RoomTaxFormatIsInvalid = "93437"
+          RoomTaxIsTooLarge = "93438"
+          NoShowIndicatorIsInvalid = "93439"
+          AdvancedDepositIndicatorIsInvalid = "93440"
+          FireSafetyIndicatorIsInvalid = "93441"
+          PropertyPhoneIsInvalid = "93442"
         end
 
         module TravelCruise
@@ -496,6 +511,15 @@ module Braintree
             TicketNumberIsTooLong = "96320"
           end
         end
+
+        module AdditionalCharge
+          KindIsInvalid = "96601"
+          KindMustBeUnique = "96602"
+          AmountMustBeGreaterThanZero = "96603"
+          AmountFormatIsInvalid = "96604"
+          AmountIsTooLarge = "96605"
+          AmountIsRequired = "96606"
+        end
       end
 
       module ExternalVault

data/lib/braintree/test/nonce.rb

@@ -6,7 +6,7 @@ module Braintree
       PayPalOneTimePayment = "fake-paypal-one-time-nonce"
       PayPalFuturePayment = "fake-paypal-future-nonce"
       PayPalBillingAgreement = "fake-paypal-billing-agreement-nonce"
-      LocalPayment = "fake-local-payment-nonce"
+      LocalPayment = "fake-local-payment-method-nonce"
       ApplePayVisa = "fake-apple-pay-visa-nonce"
       ApplePayMasterCard = "fake-apple-pay-mastercard-nonce"
       ApplePayAmEx = "fake-apple-pay-amex-nonce"

data/lib/braintree/transaction.rb

@@ -64,6 +64,17 @@ module Braintree
       All = constants.map { |c| const_get(c) }
     end
 
+    module AdditionalCharge
+      Restaurant = "restaurant"
+      GiftShop = "gift_shop"
+      MiniBar = "mini_bar"
+      Telephone = "telephone"
+      Laundry = "laundry"
+      Other = "other"
+
+      All = constants.map { |c| const_get(c) }
+    end
+
     module Type # :nodoc:
       Credit = "credit" # :nodoc:
       Sale = "sale" # :nodoc:

data/lib/braintree/transaction/local_payment_details.rb

@@ -3,11 +3,18 @@ module Braintree
     class LocalPaymentDetails
       include BaseModule
 
+      attr_reader :capture_id
       attr_reader :custom_field
+      attr_reader :debug_id
       attr_reader :description
       attr_reader :funding_source
       attr_reader :payer_id
       attr_reader :payment_id
+      attr_reader :refund_from_transaction_fee_amount
+      attr_reader :refund_from_transaction_fee_currency_iso_code
+      attr_reader :refund_id
+      attr_reader :transaction_fee_amount
+      attr_reader :transaction_fee_currency_iso_code
 
       def initialize(attributes)
         set_instance_variables_from_hash attributes unless attributes.nil?

data/lib/braintree/transaction_gateway.rb

@@ -205,6 +205,11 @@ module Braintree
             :eci_flag,
             :cavv,
             :xid,
+            :three_d_secure_version,
+            :authentication_response,
+            :directory_response,
+            :cavv_algorithm,
+            :ds_transaction_id,
           ]
         },
         {:options => [
@@ -237,13 +242,16 @@ module Braintree
         {:industry => [
           :industry_type,
           {:data => [
-            :folio_number, :check_in_date, :check_out_date, :travel_package, :lodging_check_in_date, :lodging_check_out_date, :departure_date, :lodging_name, :room_rate,
+            :folio_number, :check_in_date, :check_out_date, :travel_package, :lodging_check_in_date, :lodging_check_out_date, :departure_date, :lodging_name, :room_rate, :room_tax,
             :passenger_first_name, :passenger_last_name, :passenger_middle_initial, :passenger_title, :issued_date, :travel_agency_name, :travel_agency_code, :ticket_number,
-            :issuing_carrier_code, :customer_code, :fare_amount, :fee_amount, :tax_amount, :restricted_ticket,
+            :issuing_carrier_code, :customer_code, :fare_amount, :fee_amount, :tax_amount, :restricted_ticket, :no_show, :advanced_deposit, :fire_safe, :property_phone,
             {:legs => [
               :conjunction_ticket, :exchange_ticket, :coupon_number, :service_class, :carrier_code, :fare_basis_code, :flight_number, :departure_date, :departure_airport_code, :departure_time,
               :arrival_airport_code, :arrival_time, :stopover_permitted, :fare_amount, :fee_amount, :tax_amount, :endorsement_or_restrictions,
             ]},
+            {:additional_charges => [
+              :kind, :amount,
+            ]},
           ]},
         ]},
         {:apple_pay_card => [:number, :cardholder_name, :cryptogram, :expiration_month, :expiration_year, :eci_indicator]},

data/lib/braintree/version.rb

@@ -1,7 +1,7 @@
 module Braintree
   module Version
     Major = 2
-    Minor = 96
+    Minor = 97
     Tiny = 0
 
     String = "#{Major}.#{Minor}.#{Tiny}"

data/spec/integration/braintree/credit_card_spec.rb

@@ -550,6 +550,75 @@ describe Braintree::CreditCard do
         credit_card.card_type.should == Braintree::CreditCard::CardType::Elo
       end
     end
+
+    context "verification_account_type" do
+      it "verifies card with account_type debit" do
+        customer = Braintree::Customer.create!
+        result = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::Hiper,
+          :expiration_month => "11",
+          :expiration_year => "2099",
+          :options => {
+            :verify_card => true,
+            :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+            :verification_account_type => "debit",
+          }
+        )
+
+        expect(result).to be_success
+      end
+
+      it "verifies card with account_type credit" do
+        customer = Braintree::Customer.create!
+        result = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::Hiper,
+          :expiration_month => "11",
+          :expiration_year => "2099",
+          :options => {
+            :verify_card => true,
+            :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+            :verification_account_type => "credit",
+          }
+        )
+
+        expect(result).to be_success
+      end
+
+      it "errors with invalid account_type" do
+        customer = Braintree::Customer.create!
+        result = Braintree::CreditCard.create(
+          :number => Braintree::Test::CreditCardNumbers::Hiper,
+          :expiration_month => "11",
+          :expiration_year => "2099",
+          :options => {
+            :verify_card => true,
+            :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+            :verification_account_type => "ach",
+          }
+        )
+
+        expect(result).to_not be_success
+        expect(result.errors.for(:credit_card).for(:options).on(:verification_account_type)[0].code).to eq Braintree::ErrorCodes::CreditCard::VerificationAccountTypeIsInvalid
+      end
+
+      it "errors when account_type not supported by merchant" do
+        customer = Braintree::Customer.create!
+        result = Braintree::CreditCard.create(
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_month => "11",
+          :expiration_year => "2099",
+          :options => {
+            :verify_card => true,
+            :verification_account_type => "credit",
+          }
+        )
+
+        expect(result).to_not be_success
+        expect(result.errors.for(:credit_card).for(:options).on(:verification_account_type)[0].code).to eq Braintree::ErrorCodes::CreditCard::VerificationAccountTypeNotSupported
+      end
+    end
   end
 
   describe "self.create!" do
@@ -937,6 +1006,44 @@ describe Braintree::CreditCard do
       Braintree::CreditCard.find(card1.token).should_not be_default
       Braintree::CreditCard.find(card2.token).should be_default
     end
+
+    context "verification_account_type" do
+      it "updates the credit card with account_type credit" do
+        customer = Braintree::Customer.create!
+        card = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::Hiper,
+          :expiration_date => "06/2013",
+        ).credit_card
+        update_result = Braintree::CreditCard.update(
+          card.token,
+          :options => {
+            :verify_card => true,
+            :verification_account_type => "credit",
+            :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+          },
+        )
+        expect(update_result).to be_success
+      end
+
+      it "updates the credit card with account_type debit" do
+        customer = Braintree::Customer.create!
+        card = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::Hiper,
+          :expiration_date => "06/2013",
+        ).credit_card
+        update_result = Braintree::CreditCard.update(
+          card.token,
+          :options => {
+            :verify_card => true,
+            :verification_account_type => "debit",
+            :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+          },
+        )
+        expect(update_result).to be_success
+      end
+    end
   end
 
   describe "self.update!" do

data/spec/integration/braintree/customer_spec.rb

@@ -496,6 +496,97 @@ describe Braintree::Customer do
 
       result.success?.should == true
     end
+
+    context "verification_account_type" do
+      it "verifies card with account_type debit" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Hiper,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          }
+        )
+        result = Braintree::Customer.create(
+          :payment_method_nonce => nonce,
+          :credit_card => {
+            :options => {
+              :verify_card => true,
+              :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+              :verification_account_type => "debit",
+            }
+          }
+        )
+
+        expect(result).to be_success
+      end
+
+      it "verifies card with account_type credit" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Hiper,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          }
+        )
+        result = Braintree::Customer.create(
+          :payment_method_nonce => nonce,
+          :credit_card => {
+            :options => {
+              :verify_card => true,
+              :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+              :verification_account_type => "credit",
+            }
+          }
+        )
+
+        expect(result).to be_success
+      end
+
+      it "errors with invalid account_type" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Hiper,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          }
+        )
+        result = Braintree::Customer.create(
+          :payment_method_nonce => nonce,
+          :credit_card => {
+            :options => {
+              :verify_card => true,
+              :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+              :verification_account_type => "ach",
+            }
+          }
+        )
+
+        expect(result).to_not be_success
+        expect(result.errors.for(:customer).for(:credit_card).for(:options).on(:verification_account_type)[0].code).to eq Braintree::ErrorCodes::CreditCard::VerificationAccountTypeIsInvalid
+      end
+
+      it "errors when account_type not supported by merchant" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          }
+        )
+        result = Braintree::Customer.create(
+          :payment_method_nonce => nonce,
+          :credit_card => {
+            :options => {
+              :verify_card => true,
+              :verification_account_type => "credit",
+            }
+          }
+        )
+
+        expect(result).to_not be_success
+        expect(result.errors.for(:customer).for(:credit_card).for(:options).on(:verification_account_type)[0].code).to eq Braintree::ErrorCodes::CreditCard::VerificationAccountTypeNotSupported
+      end
+    end
   end
 
   describe "self.create!" do
@@ -1251,6 +1342,46 @@ describe Braintree::Customer do
       result.success?.should == false
       result.errors.for(:customer).on(:email)[0].message.should == "Email is an invalid format."
     end
+
+    context "verification_account_type" do
+      it "updates the credit card with account_type credit" do
+        customer = Braintree::Customer.create!
+        update_result = Braintree::Customer.update(
+          customer.id,
+          :credit_card => {
+            :cardholder_name => "New Holder",
+            :cvv => "456",
+            :number => Braintree::Test::CreditCardNumbers::Hiper,
+            :expiration_date => "06/2013",
+            :options => {
+              :verify_card => true,
+              :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+              :verification_account_type => "credit",
+            },
+          }
+        )
+        expect(update_result).to be_success
+      end
+
+      it "updates the credit card with account_type debit" do
+        customer = Braintree::Customer.create!
+        update_result = Braintree::Customer.update(
+          customer.id,
+          :credit_card => {
+            :cardholder_name => "New Holder",
+            :cvv => "456",
+            :number => Braintree::Test::CreditCardNumbers::Hiper,
+            :expiration_date => "06/2013",
+            :options => {
+              :verify_card => true,
+              :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+              :verification_account_type => "debit",
+            },
+          }
+        )
+        expect(update_result).to be_success
+      end
+    end
   end
 
   describe "self.update!" do

data/spec/integration/braintree/payment_method_nonce_spec.rb

@@ -83,6 +83,17 @@ describe Braintree::PaymentMethodNonce do
       nonce.details.fetch(:card_type).should == "Visa"
     end
 
+    it "return paypal details if details exist" do
+      result = Braintree::PaymentMethodNonce.find("fake-google-pay-paypal-nonce")
+
+      nonce = result.payment_method_nonce
+
+      nonce.details.fetch(:payer_info).fetch(:first_name).should_not be_nil
+      nonce.details.fetch(:payer_info).fetch(:last_name).should_not be_nil
+      nonce.details.fetch(:payer_info).fetch(:email).should_not be_nil
+      nonce.details.fetch(:payer_info).fetch(:payer_id).should_not be_nil
+    end
+
     it "return venmo details if details exist" do
       result = Braintree::PaymentMethodNonce.find("fake-venmo-account-nonce")
 

data/spec/integration/braintree/transaction_spec.rb

@@ -162,7 +162,7 @@ describe Braintree::Transaction do
         it "accepts valid industry data" do
           result = Braintree::Transaction.create(
             :type => "sale",
-            :amount => 1_00,
+            :amount => 1000_00,
             :credit_card => {
               :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
               :expiration_date => "05/2009"
@@ -172,8 +172,23 @@ describe Braintree::Transaction do
               :data => {
                 :folio_number => "ABCDEFG",
                 :check_in_date => "2014-06-01",
-                :check_out_date => "2014-06-30",
-                :room_rate => "239.00",
+                :check_out_date => "2014-06-05",
+                :room_rate => 170_00,
+                :room_tax => 30_00,
+                :no_show => false,
+                :advanced_deposit => false,
+                :fire_safe => true,
+                :property_phone => "1112223345",
+                :additional_charges => [
+                  {
+                    :kind => Braintree::Transaction::AdditionalCharge::Telephone,
+                    :amount => 50_00,
+                  },
+                  {
+                    :kind => Braintree::Transaction::AdditionalCharge::Other,
+                    :amount => 150_00,
+                  },
+                ],
               }
             }
           )
@@ -183,7 +198,7 @@ describe Braintree::Transaction do
         it "returns errors if validations on industry lodging data fails" do
           result = Braintree::Transaction.create(
             :type => "sale",
-            :amount => 1_00,
+            :amount => 500_00,
             :credit_card => {
               :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
               :expiration_date => "05/2009"
@@ -195,13 +210,22 @@ describe Braintree::Transaction do
                 :check_in_date => "2014-06-30",
                 :check_out_date => "2014-06-01",
                 :room_rate => "asdfasdf",
+                :additional_charges => [
+                  {
+                    :kind => "unknown",
+                    :amount => 20_00,
+                  },
+                ],
               }
             }
           )
           result.success?.should be(false)
           invalid_folio = Braintree::ErrorCodes::Transaction::Industry::Lodging::FolioNumberIsInvalid
           check_out_date_must_follow_check_in_date = Braintree::ErrorCodes::Transaction::Industry::Lodging::CheckOutDateMustFollowCheckInDate
-          result.errors.for(:transaction).for(:industry).map { |e| e.code }.sort.should include *[invalid_folio, check_out_date_must_follow_check_in_date]
+          room_rate_format_is_invalid = Braintree::ErrorCodes::Transaction::Industry::Lodging::RoomRateFormatIsInvalid
+          invalid_additional_charge_kind = Braintree::ErrorCodes::Transaction::Industry::AdditionalCharge::KindIsInvalid
+          result.errors.for(:transaction).for(:industry).map { |e| e.code }.sort.should include *[invalid_folio, check_out_date_must_follow_check_in_date, room_rate_format_is_invalid]
+          result.errors.for(:transaction).for(:industry).for(:additional_charges).for(:index_0).on(:kind).map { |e| e.code }.sort.should include *[invalid_additional_charge_kind]
         end
       end
 
@@ -1148,9 +1172,9 @@ describe Braintree::Transaction do
           result = Braintree::Transaction.sale(
             :amount => Braintree::Test::TransactionAmounts::Authorize,
             :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "05/2009"
-          },
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/2009"
+            },
             :tax_amount => 'abcd'
           )
           result.success?.should == false
@@ -1161,9 +1185,9 @@ describe Braintree::Transaction do
           result = Braintree::Transaction.sale(
             :amount => Braintree::Test::TransactionAmounts::Authorize,
             :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "05/2009"
-          },
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/2009"
+            },
             :purchase_order_number => 'a' * 18
           )
           result.success?.should == false
@@ -1174,9 +1198,9 @@ describe Braintree::Transaction do
           result = Braintree::Transaction.sale(
             :amount => Braintree::Test::TransactionAmounts::Authorize,
             :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "05/2009"
-          },
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/2009"
+            },
             :purchase_order_number => "\303\237\303\245\342\210\202"
           )
           result.success?.should == false
@@ -2113,6 +2137,11 @@ describe Braintree::Transaction do
             :eci_flag => "02",
             :cavv => "some_cavv",
             :xid => "some_xid",
+            :three_d_secure_version => "1.0.2",
+            :authentication_response => "Y",
+            :directory_response => "Y",
+            :cavv_algorithm => "2",
+            :ds_transaction_id => "some_ds_id",
           }
         )
 
@@ -2133,6 +2162,11 @@ describe Braintree::Transaction do
             :eci_flag => "02",
             :cavv => "some_cavv",
             :xid => "some_xid",
+            :three_d_secure_version => "1.0.2",
+            :authentication_response => "Y",
+            :directory_response => "Y",
+            :cavv_algorithm => "2",
+            :ds_transaction_id => "some_ds_id",
           }
         )
         result.success?.should == false
@@ -2169,6 +2203,11 @@ describe Braintree::Transaction do
             :eci_flag => "05",
             :cavv => "",
             :xid => "",
+            :three_d_secure_version => "1.0.2",
+            :authentication_response => "Y",
+            :directory_response => "Y",
+            :cavv_algorithm => "2",
+            :ds_transaction_id => "some_ds_id",
           }
         )
         result.success?.should == false
@@ -2187,13 +2226,111 @@ describe Braintree::Transaction do
             :eci_flag => "bad_eci_flag",
             :cavv => "some_cavv",
             :xid => "some_xid",
+            :three_d_secure_version => "1.0.2",
+            :authentication_response => "Y",
+            :directory_response => "Y",
+            :cavv_algorithm => "2",
+            :ds_transaction_id => "some_ds_id",
           }
         )
         result.success?.should == false
         result.errors.for(:transaction).for(:three_d_secure_pass_thru).on(:eci_flag)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureEciFlagIsInvalid
       end
 
+      it "returns an error for transaction when the three_d_secure_pass_thru three_d_secure_version is invalid" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/12",
+          },
+          :three_d_secure_pass_thru => {
+            :eci_flag => "02",
+            :cavv => "some_cavv",
+            :xid => "some_xid",
+            :three_d_secure_version => "invalid",
+            :authentication_response => "Y",
+            :directory_response => "Y",
+            :cavv_algorithm => "2",
+            :ds_transaction_id => "some_ds_id",
+          }
+        )
+        result.success?.should == false
+        result.errors.for(:transaction).for(:three_d_secure_pass_thru).on(:three_d_secure_version)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureThreeDSecureVersionIsInvalid
+      end
 
+      it "returns an error for transaction when the three_d_secure_pass_thru authentication_response is invalid" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :merchant_account_id => SpecHelper:: AdyenMerchantAccountId,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/12",
+          },
+          :three_d_secure_pass_thru => {
+            :eci_flag => "02",
+            :cavv => "some_cavv",
+            :xid => "some_xid",
+            :three_d_secure_version => "1.0.2",
+            :authentication_response => "asdf",
+            :directory_response => "Y",
+            :cavv_algorithm => "2",
+            :ds_transaction_id => "some_ds_id",
+          }
+        )
+        result.success?.should == false
+        result.errors.for(:transaction).for(:three_d_secure_pass_thru).on(:authentication_response)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureAuthenticationResponseIsInvalid
+      end
+
+      it "returns an error for transaction when the three_d_secure_pass_thru directory_response is invalid" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :merchant_account_id => SpecHelper:: AdyenMerchantAccountId,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/12",
+          },
+          :three_d_secure_pass_thru => {
+            :eci_flag => "02",
+            :cavv => "some_cavv",
+            :xid => "some_xid",
+            :three_d_secure_version => "1.0.2",
+            :authentication_response => "Y",
+            :directory_response => "abc",
+            :cavv_algorithm => "2",
+            :ds_transaction_id => "some_ds_id",
+          }
+        )
+        result.success?.should == false
+        result.errors.for(:transaction).for(:three_d_secure_pass_thru).on(:directory_response)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureDirectoryResponseIsInvalid
+      end
+
+      it "returns an error for transaction when the three_d_secure_pass_thru cavv_algorithm is invalid" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :merchant_account_id => SpecHelper:: AdyenMerchantAccountId,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/12",
+          },
+          :three_d_secure_pass_thru => {
+            :eci_flag => "02",
+            :cavv => "some_cavv",
+            :xid => "some_xid",
+            :three_d_secure_version => "1.0.2",
+            :authentication_response => "Y",
+            :directory_response => "Y",
+            :cavv_algorithm => "bad_alg",
+            :ds_transaction_id => "some_ds_id",
+          }
+        )
+        result.success?.should == false
+        result.errors.for(:transaction).for(:three_d_secure_pass_thru).on(:cavv_algorithm)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureCavvAlgorithmIsInvalid
+      end
     end
 
     context "paypal" do
@@ -2275,6 +2412,9 @@ describe Braintree::Transaction do
           result.transaction.local_payment_details.should_not be_nil
           result.transaction.local_payment_details.funding_source.should_not be_nil
           result.transaction.local_payment_details.payment_id.should_not be_nil
+          result.transaction.local_payment_details.capture_id.should_not be_nil
+          result.transaction.local_payment_details.transaction_fee_amount.should_not be_nil
+          result.transaction.local_payment_details.transaction_fee_currency_iso_code.should_not be_nil
         end
       end
 
@@ -3941,118 +4081,118 @@ describe Braintree::Transaction do
 
     context "account_type" do
       it "creates a Hiper transaction with account type credit" do
-          result = Braintree::Transaction.create(
-            :type => "sale",
-            :merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Hiper,
+            :expiration_date => "05/2009"
+          },
+          :amount => "10.00",
+          :options => {
             :credit_card => {
-              :number => Braintree::Test::CreditCardNumbers::Hiper,
-              :expiration_date => "05/2009"
-            },
-            :amount => "10.00",
-            :options => {
-              :credit_card => {
-                :account_type => "credit",
-              }
+              :account_type => "credit",
             }
-          )
-          result.success?.should == true
-          result.transaction.credit_card_details.account_type.should == "credit"
-       end
+          }
+        )
+        result.success?.should == true
+        result.transaction.credit_card_details.account_type.should == "credit"
+      end
 
-       it "creates a Hipercard transaction with account_type credit" do
-          result = Braintree::Transaction.create(
-            :type => "sale",
-            :merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+      it "creates a Hipercard transaction with account_type credit" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Hipercard,
+            :expiration_date => "05/2009"
+          },
+          :amount => "10.00",
+          :options => {
             :credit_card => {
-              :number => Braintree::Test::CreditCardNumbers::Hipercard,
-              :expiration_date => "05/2009"
-            },
-            :amount => "10.00",
-            :options => {
-              :credit_card => {
-                :account_type => "credit",
-              }
+              :account_type => "credit",
             }
-          )
-          result.success?.should == true
-          result.transaction.credit_card_details.account_type.should == "credit"
-       end
+          }
+        )
+        result.success?.should == true
+        result.transaction.credit_card_details.account_type.should == "credit"
+      end
 
-       it "creates a Hiper transaction with account_type debit" do
-          result = Braintree::Transaction.create(
-            :type => "sale",
-            :merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+      it "creates a Hiper transaction with account_type debit" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Hiper,
+            :expiration_date => "05/2009"
+          },
+          :amount => "10.00",
+          :options => {
             :credit_card => {
-              :number => Braintree::Test::CreditCardNumbers::Hiper,
-              :expiration_date => "05/2009"
+              :account_type => "debit",
             },
-            :amount => "10.00",
-            :options => {
-              :credit_card => {
-                :account_type => "debit",
-              },
-              :submit_for_settlement => true,
-            }
-          )
-          result.success?.should == true
-          result.transaction.credit_card_details.account_type.should == "debit"
-       end
+            :submit_for_settlement => true,
+          }
+        )
+        result.success?.should == true
+        result.transaction.credit_card_details.account_type.should == "debit"
+      end
 
-       it "does not allow auths with account_type debit" do
-          result = Braintree::Transaction.create(
-            :type => "sale",
-            :merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+      it "does not allow auths with account_type debit" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Hiper,
+            :expiration_date => "05/2009"
+          },
+          :amount => "10.00",
+          :options => {
             :credit_card => {
-              :number => Braintree::Test::CreditCardNumbers::Hiper,
-              :expiration_date => "05/2009"
+              :account_type => "debit",
             },
-            :amount => "10.00",
-            :options => {
-              :credit_card => {
-                :account_type => "debit",
-              },
-            }
-          )
-          result.success?.should == false
-          result.errors.for(:transaction).for(:options).for(:credit_card).on(:account_type)[0].code.should == Braintree::ErrorCodes::Transaction::Options::CreditCard::AccountTypeDebitDoesNotSupportAuths
-       end
+          }
+        )
+        result.success?.should == false
+        result.errors.for(:transaction).for(:options).for(:credit_card).on(:account_type)[0].code.should == Braintree::ErrorCodes::Transaction::Options::CreditCard::AccountTypeDebitDoesNotSupportAuths
+      end
 
-       it "does not allow invalid account_type" do
-          result = Braintree::Transaction.create(
-            :type => "sale",
-            :merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+      it "does not allow invalid account_type" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Hiper,
+            :expiration_date => "05/2009"
+          },
+          :amount => "10.00",
+          :options => {
             :credit_card => {
-              :number => Braintree::Test::CreditCardNumbers::Hiper,
-              :expiration_date => "05/2009"
+              :account_type => "ach",
             },
-            :amount => "10.00",
-            :options => {
-              :credit_card => {
-                :account_type => "ach",
-              },
-            }
-          )
-          result.success?.should == false
-          result.errors.for(:transaction).for(:options).for(:credit_card).on(:account_type)[0].code.should == Braintree::ErrorCodes::Transaction::Options::CreditCard::AccountTypeIsInvalid
-       end
+          }
+        )
+        result.success?.should == false
+        result.errors.for(:transaction).for(:options).for(:credit_card).on(:account_type)[0].code.should == Braintree::ErrorCodes::Transaction::Options::CreditCard::AccountTypeIsInvalid
+      end
 
-       it "does not allow account_type not supported by merchant" do
-          result = Braintree::Transaction.create(
-            :type => "sale",
+      it "does not allow account_type not supported by merchant" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          },
+          :amount => "10.00",
+          :options => {
             :credit_card => {
-              :number => Braintree::Test::CreditCardNumbers::Visa,
-              :expiration_date => "05/2009"
+              :account_type => "credit",
             },
-            :amount => "10.00",
-            :options => {
-              :credit_card => {
-                :account_type => "credit",
-              },
-            }
-          )
-          result.success?.should == false
-          result.errors.for(:transaction).for(:options).for(:credit_card).on(:account_type)[0].code.should == Braintree::ErrorCodes::Transaction::Options::CreditCard::AccountTypeNotSupported
-       end
+          }
+        )
+        result.success?.should == false
+        result.errors.for(:transaction).for(:options).for(:credit_card).on(:account_type)[0].code.should == Braintree::ErrorCodes::Transaction::Options::CreditCard::AccountTypeNotSupported
+      end
     end
   end
 
@@ -4843,11 +4983,11 @@ describe Braintree::Transaction do
       )
 
       options = {
-          :descriptor => {
-            :name => '123*123456789012345678',
-            :phone => '3334445555',
-            :url => "ebay.com"
-          }
+        :descriptor => {
+          :name => '123*123456789012345678',
+          :phone => '3334445555',
+          :url => "ebay.com"
+        }
       }
 
       result = Braintree::Transaction.submit_for_settlement(transaction.id, nil, options)

data/spec/spec_helper.rb

@@ -5,6 +5,7 @@ unless defined?(SPEC_HELPER_LOADED)
   require "bundler/setup"
   require "rspec"
   require "libxml"
+  require "pry"
 
   braintree_lib = "#{project_root}/lib"
   $LOAD_PATH << braintree_lib

data/spec/unit/braintree/credit_card_spec.rb

@@ -25,7 +25,7 @@ describe Braintree::CreditCard do
         :device_data,
         :fraud_merchant_id,
         :payment_method_nonce,
-        {:options => [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method]},
+        {:options => [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type]},
         {:billing_address => [
           :company,
           :country_code_alpha2,
@@ -61,7 +61,7 @@ describe Braintree::CreditCard do
         :device_data,
         :fraud_merchant_id,
         :payment_method_nonce,
-        {:options => [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method]},
+        {:options => [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type]},
         {:billing_address => [
           :company,
           :country_code_alpha2,

data/spec/unit/braintree/customer_spec.rb

@@ -101,7 +101,7 @@ describe Braintree::Customer do
           :device_data,
           :fraud_merchant_id,
           :payment_method_nonce,
-          {:options => [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method]},
+          {:options => [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type]},
           {:billing_address => [
             :company,
             :country_code_alpha2,
@@ -186,6 +186,7 @@ describe Braintree::Customer do
             :verification_amount,
             :venmo_sdk_session,
             :fail_on_duplicate_payment_method,
+            :verification_account_type,
             :update_existing_token
           ]},
           {:billing_address => [

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: braintree
 version: !ruby/object:Gem::Version
-  version: 2.96.0
+  version: 2.97.0
 platform: ruby
 authors:
 - Braintree
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-20 00:00:00.000000000 Z
+date: 2019-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -318,7 +318,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.4
 signing_key: 
 specification_version: 4
 summary: Braintree Gateway Ruby Client Library