braintree 2.100.0 → 2.101.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce8a0ffb1227a51cbb8d3f53339a7b9c6f4ea4cb934a1f8650fe0376394c5e3d
-  data.tar.gz: b500561e20d50b0b30b816fe9152d2cf838555304a544508d800f4f8202e02c4
+  metadata.gz: 4a5d32a025ec741caa8fd1de8f33b64951f8e61cf6c16dbfd32b12ec0d88d81a
+  data.tar.gz: e7500376e7de67a7ebda3c275b22235dc298d386edec860994aa15c129807006
 SHA512:
-  metadata.gz: d86f151ea614c6c8f5f1297873efa2c8a7e1f567bd05b06fbb9aa6216ef45ccd3b3d6aef0d40204028b05a7bd8fcfa010d9b3670fdd5a88babcc81fdfb7d3a48
-  data.tar.gz: 70efed7f2733dd6055fc868ca7ff7bf104dcc550a6499c7fe10bb7c1f17f33e4c686eee676463af6bd4725d1a298816871418accba721ad840b6b1d8821006ca
+  metadata.gz: 5f8f63a4af2e318f9ac5b9fcbd88f8e7b185e61f9f0fa4e090a75a66ce0c534a50b712af237b8d22b0741319a2764a081991be0b7d8535ab4246858dd8150600
+  data.tar.gz: 23cc9b627afc2804750d41a64bbdae27a5ad68df550a7aaebc4c291b96dd31265569ed917cb980952a47190aee52c5d0a04192dbe5e72850eedb534a25419508

data/lib/braintree/android_pay_card.rb

@@ -29,6 +29,10 @@ module Braintree
       @default
     end
 
+    def is_network_tokenized?
+      @is_network_tokenized
+    end
+
     def card_type
       virtual_card_type
     end

data/lib/braintree/base_module.rb

@@ -18,6 +18,10 @@ module Braintree
 
       def set_instance_variables_from_hash(hash)
         hash.each do |key, value|
+          if key == :global_id
+            instance_variable_set "@graphql_id", value
+          end
+
           instance_variable_set "@#{key}", value
         end
       end

data/lib/braintree/credit_card_verification.rb

@@ -22,6 +22,7 @@ module Braintree
     attr_reader :currency_iso_code
     attr_reader :cvv_response_code
     attr_reader :gateway_rejection_reason
+    attr_reader :graphql_id
     attr_reader :id
     attr_reader :merchant_account_id
     attr_reader :network_response_code

data/lib/braintree/customer.rb

@@ -15,6 +15,7 @@ module Braintree
     attr_reader :email
     attr_reader :fax
     attr_reader :first_name
+    attr_reader :graphql_id
     attr_reader :id
     attr_reader :last_name
     attr_reader :masterpass_cards

data/lib/braintree/dispute.rb

@@ -12,6 +12,7 @@ module Braintree
     attr_reader :date_opened
     attr_reader :date_won
     attr_reader :evidence
+    attr_reader :graphql_id
     attr_reader :id
     attr_reader :kind
     attr_reader :merchant_account_id

data/lib/braintree/error_codes.rb

@@ -323,29 +323,21 @@ module Braintree
       CannotUpdateTransactionDetailsNotSubmittedForSettlement = "915129"
       ChannelIsTooLong = "91550"
       CreditCardIsRequired = "91508"
-      CustomFieldIsInvalid = "91526"
-      CustomFieldIsTooLong = "81527"
       CustomerDefaultPaymentMethodCardTypeIsNotAccepted = "81509"
       CustomerDoesNotHaveCreditCard = "91511"
       CustomerIdIsInvalid = "91510"
+      CustomFieldIsInvalid = "91526"
+      CustomFieldIsTooLong = "81527"
+      DiscountAmountCannotBeNegative = "915160"
+      DiscountAmountFormatIsInvalid = "915159"
+      DiscountAmountIsTooLarge = "915161"
       FailedAuthAdjustmentAllowRetry = "95603"
       FailedAuthAdjustmentHardDecline = "95602"
       FinalAuthSubmitForSettlementForDifferentAmount = "95601"
       HasAlreadyBeenRefunded = "91512"
       IdealPaymentNotComplete = "815141"
-      PaymentInstrumentWithExternalVaultIsInvalid = "915176"
-      TooManyLineItems = "915157"
-      LineItemsExpected = "915158"
-      DiscountAmountFormatIsInvalid = "915159"
-      DiscountAmountCannotBeNegative = "915160"
-      DiscountAmountIsTooLarge = "915161"
-      ShippingAmountFormatIsInvalid = "915162"
-      ShippingAmountCannotBeNegative = "915163"
-      ShippingAmountIsTooLarge = "915164"
-      ShipsFromPostalCodeIsTooLong = "915165"
-      ShipsFromPostalCodeIsInvalid = "915166"
-      ShipsFromPostalCodeInvalidCharacters = "915167"
       IdealPaymentsCannotBeVaulted = "915150"
+      LineItemsExpected = "915158"
       MerchantAccountDoesNotMatch3DSecureMerchantAccount = "91584"
       MerchantAccountDoesNotMatchIdealPaymentMerchantAccount = "915143"
       MerchantAccountDoesNotSupportMOTO = "91558"
@@ -353,14 +345,12 @@ module Braintree
       MerchantAccountIdDoesNotMatchSubscription = "915180"
       MerchantAccountIdIsInvalid = "91513"
       MerchantAccountIsSuspended = "91514"
-      OrderIdIsTooLong = "91501"
-      OrderIdIsRequiredWithIdealPayment = "91502"
       OrderIdDoesNotMatchIdealPaymentOrderId = "91503"
-      PayPalAuthExpired = "91579"
-      PayPalNotEnabled = "91576"
-      PayPalVaultRecordMissingData = "91583"
+      OrderIdIsRequiredWithIdealPayment = "91502"
+      OrderIdIsTooLong = "91501"
       PaymentInstrumentNotSupportedByMerchantAccount = "91577"
       PaymentInstrumentTypeIsNotAccepted = "915101"
+      PaymentInstrumentWithExternalVaultIsInvalid = "915176"
       PaymentMethodConflict = "91515"
       PaymentMethodConflictWithVenmoSDK = "91549"
       PaymentMethodDoesNotBelongToCustomer = "91516"
@@ -368,25 +358,28 @@ module Braintree
       PaymentMethodNonceCardTypeIsNotAccepted = "91567"
       PaymentMethodNonceConsumed = "91564"
       PaymentMethodNonceHasNoValidPaymentInstrumentType = "91569"
-      UsBankAccountNonceMustBePlaidVerified = "915171"
-      UsBankAccountNotVerified = "915172"
       PaymentMethodNonceLocked = "91566"
       PaymentMethodNonceUnknown = "91565"
       PaymentMethodTokenCardTypeIsNotAccepted = "91517"
       PaymentMethodTokenIsInvalid = "91518"
+      PayPalAuthExpired = "91579"
+      PayPalNotEnabled = "91576"
+      PayPalVaultRecordMissingData = "91583"
       ProcessorAuthorizationCodeCannotBeSet = "91519"
       ProcessorAuthorizationCodeIsInvalid = "81520"
       ProcessorDoesNotSupportAuths = "915104"
-      ProcessorDoesNotSupportUpdatingOrderId = "915107"
-      ProcessorDoesNotSupportUpdatingDescriptor = "915108"
-      ProcessorDoesNotSupportUpdatingTransactionDetails = "915130"
       ProcessorDoesNotSupportCredits = "91546"
+      ProcessorDoesNotSupportMotoForCardType = "915195"
       ProcessorDoesNotSupportPartialSettlement = "915102"
+      ProcessorDoesNotSupportUpdatingDescriptor = "915108"
+      ProcessorDoesNotSupportUpdatingOrderId = "915107"
+      ProcessorDoesNotSupportUpdatingTransactionDetails = "915130"
       ProcessorDoesNotSupportVoiceAuthorizations = "91545"
-      ProcessorDoesNotSupportMotoForCardType = "915195"
       PurchaseOrderNumberIsInvalid = "91548"
       PurchaseOrderNumberIsTooLong = "91537"
       RefundAmountIsTooLarge = "91521"
+      RefundAuthHardDeclined = "915200"
+      RefundAuthSoftDeclined = "915201"
       ServiceFeeAmountCannotBeNegative = "91554"
       ServiceFeeAmountFormatIsInvalid = "91555"
       ServiceFeeAmountIsTooLarge = "91556"
@@ -396,6 +389,12 @@ module Braintree
       SettlementAmountIsLessThanServiceFeeAmount = "91551"
       SettlementAmountIsTooLarge = "91522"
       ShippingAddressDoesntMatchCustomer = "91581"
+      ShippingAmountCannotBeNegative = "915163"
+      ShippingAmountFormatIsInvalid = "915162"
+      ShippingAmountIsTooLarge = "915164"
+      ShipsFromPostalCodeInvalidCharacters = "915167"
+      ShipsFromPostalCodeIsInvalid = "915166"
+      ShipsFromPostalCodeIsTooLong = "915165"
       SubMerchantAccountRequiresServiceFeeAmount = "91553"
       SubscriptionDoesNotBelongToCustomer = "91529"
       SubscriptionIdIsInvalid = "91528"
@@ -404,21 +403,28 @@ module Braintree
       TaxAmountFormatIsInvalid = "81535"
       TaxAmountIsTooLarge = "81536"
       ThreeDSecureAuthenticationFailed = "81571"
-      ThreeDSecureTokenIsInvalid = "91568"
-      ThreeDSecureTransactionDataDoesntMatchVerify = "91570"
-      ThreeDSecureEciFlagIsRequired = "915113"
-      ThreeDSecureCavvIsRequired = "915116"
-      ThreeDSecureXidIsRequired = "915115"
-      ThreeDSecureEciFlagIsInvalid = "915114"
-      ThreeDSecureThreeDSecureVersionIsInvalid = "915119"
+      ThreeDSecureAuthenticationIdDoesntMatchNonceThreeDSecureAuthentication = "915198"
+      ThreeDSecureAuthenticationIdIsInvalid = "915196"
+      ThreeDSecureAuthenticationIdWithThreeDSecurePassThruIsInvalid = "915199"
       ThreeDSecureAuthenticationResponseIsInvalid = "915120"
-      ThreeDSecureDirectoryResponseIsInvalid = "915121"
       ThreeDSecureCavvAlgorithmIsInvalid = "915122"
+      ThreeDSecureCavvIsRequired = "915116"
+      ThreeDSecureDirectoryResponseIsInvalid = "915121"
+      ThreeDSecureEciFlagIsInvalid = "915114"
+      ThreeDSecureEciFlagIsRequired = "915113"
       ThreeDSecureMerchantAccountDoesNotSupportCardType = "915131"
+      ThreeDSecureThreeDSecureVersionIsInvalid = "915119"
+      ThreeDSecureTokenIsInvalid = "91568"
+      ThreeDSecureTransactionDataDoesntMatchVerify = "91570"
+      ThreeDSecureTransactionPaymentMethodDoesntMatchThreeDSecureAuthenticationPaymentMethod = "915197"
+      ThreeDSecureXidIsRequired = "915115"
+      TooManyLineItems = "915157"
+      TransactionSourceIsInvalid = "915133"
       TypeIsInvalid = "91523"
       TypeIsRequired = "91524"
       UnsupportedVoiceAuthorization = "91539"
-      TransactionSourceIsInvalid = "915133"
+      UsBankAccountNonceMustBePlaidVerified = "915171"
+      UsBankAccountNotVerified = "915172"
 
       module Options
         SubmitForSettlementIsRequiredForCloning = "91544"

data/lib/braintree/graphql_client.rb

@@ -19,10 +19,16 @@ module Braintree
       request['variables'] = variables
 
       response = _http_do Net::HTTP::Post, @config.graphql_base_url, request.to_json, nil, graphql_connection, @graphql_headers
-      data = JSON.parse(response.body, :symbolize_names => true)
+      data = _parse_response(response)
       Util.raise_exception_for_graphql_error(data)
 
       data
     end
+
+    def _parse_response(response)
+      body = response.body
+      body = Zlib::GzipReader.new(StringIO.new(body)).read if response.header['Content-Encoding'] == "gzip"
+      JSON.parse(body, :symbolize_names => true)
+    end
   end
 end

data/lib/braintree/payment_method_gateway.rb

@@ -178,6 +178,7 @@ module Braintree
         options << :fail_on_duplicate_payment_method
         signature << :customer_id
         signature << :paypal_refresh_token
+        # NEXT_MAJOR_VERSION remove this from the signature
         signature << :paypal_vault_without_upgrade
       when :update
         billing_address_params << {:options => [:update_existing]}

data/lib/braintree/three_d_secure_info.rb

@@ -11,6 +11,7 @@ module Braintree
     attr_reader :eci_flag
     attr_reader :three_d_secure_version
     attr_reader :ds_transaction_id
+    attr_reader :three_d_secure_authentication_id
 
     alias_method :liability_shifted?, :liability_shifted
     alias_method :liability_shift_possible?, :liability_shift_possible
@@ -30,6 +31,7 @@ module Braintree
         :eci_flag,
         :three_d_secure_version,
         :ds_transaction_id,
+        :three_d_secure_authentication_id,
       ]
 
       formatted_attrs = attr_order.map do |attr|

data/lib/braintree/transaction.rb

@@ -119,6 +119,7 @@ module Braintree
     attr_reader :facilitated_details
     attr_reader :facilitator_details
     attr_reader :gateway_rejection_reason
+    attr_reader :graphql_id
     attr_reader :id
     # NEXT_MAJOR_VERSION Remove this class as legacy Ideal has been removed/disabled in the Braintree Gateway
     # DEPRECATED If you're looking to accept iDEAL as a payment method contact accounts@braintreepayments.com for a solution.

data/lib/braintree/transaction/android_pay_details.rb

@@ -32,6 +32,10 @@ module Braintree
         @card_type = @virtual_card_type
         @last_4 = @virtual_card_last_4
       end
+
+      def is_network_tokenized?
+        @is_network_tokenized
+      end
     end
   end
 end

data/lib/braintree/transaction_gateway.rb

@@ -188,7 +188,7 @@ module Braintree
         :purchase_order_number, :recurring, :transaction_source, :shipping_address_id, :type, :tax_amount, :tax_exempt,
         :venmo_sdk_payment_method_code, :device_session_id, :service_fee_amount, :device_data, :fraud_merchant_id,
         :shipping_amount, :discount_amount, :ships_from_postal_code,
-        :billing_address_id, :payment_method_nonce, :three_d_secure_token,
+        :billing_address_id, :payment_method_nonce, :three_d_secure_token, :three_d_secure_authentication_id,
         :shared_payment_method_token, :shared_billing_address_id, :shared_customer_id, :shared_shipping_address_id, :shared_payment_method_nonce,
         {:line_items => [:quantity, :name, :description, :kind, :unit_amount, :unit_tax_amount, :total_amount, :discount_amount, :tax_amount, :unit_of_measure, :product_code, :commodity_code, :url]},
         {:risk_data => [:customer_browser, :customer_ip]},
@@ -263,6 +263,13 @@ module Braintree
       [
         :order_id,
         {:descriptor => [:name, :phone, :url]},
+        :purchase_order_number,
+        :tax_amount,
+        :tax_exempt,
+        :discount_amount,
+        :shipping_amount,
+        :ships_from_postal_code,
+        :line_items => [:commodity_code, :description, :discount_amount, :kind, :name, :product_code, :quantity, :tax_amount, :total_amount, :unit_amount, :unit_of_measure, :unit_tax_amount, :url, :tax_amount],
       ]
     end
 

data/lib/braintree/version.rb

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

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

@@ -56,83 +56,93 @@ def nonce_for_paypal_account(paypal_account_details)
 end
 
 def generate_non_plaid_us_bank_account_nonce(account_number="1000000000")
-  raw_client_token = Braintree::ClientToken.generate
-  client_token = decode_client_token(raw_client_token)
-
-  url = client_token["braintree_api"]["url"] + "/tokens"
-  token = client_token["braintree_api"]["access_token"]
-  payload = {
-    :type => "us_bank_account",
-    :billing_address => {
-      :street_address => "123 Ave",
-      :region => "CA",
-      :locality => "San Francisco",
-      :postal_code => "94112"
-    },
-    :account_type => "checking",
-    :routing_number => "021000021",
-    :account_number => account_number,
-    :first_name => "John",
-    :last_name => "Doe",
-    :ownership_type => "personal",
-    :ach_mandate => {
-      :text => "cl mandate text"
+  definition = <<-GRAPHQL
+mutation TokenizeUsBankAccount($input: TokenizeUsBankAccountInput!) {
+  tokenizeUsBankAccount(input: $input) {
+    paymentMethod {
+      id
     }
   }
+}
+      GRAPHQL
+  variables = {
+    input: {
+      usBankAccount: {
+        achMandate: "cl mandate text",
+        routingNumber: "021000021",
+        accountNumber: account_number,
+        accountType: "CHECKING",
+        individualOwner: {
+          firstName: "John",
+          lastName: "Doe",
+        },
+        billingAddress: {
+          streetAddress: "123 Ave",
+          city: "San Francisco",
+          state: "CA",
+          zipCode: "94112"
+        }
+      }
+    }
+  }
+  response = Braintree::GraphQLClient.new(Braintree::Configuration.instantiate).query(definition, variables)
 
-  json = _cosmos_post(token, url, payload)
-  json["data"]["id"]
+  response[:data][:tokenizeUsBankAccount][:paymentMethod][:id]
 end
 
 def generate_valid_plaid_us_bank_account_nonce
   raw_client_token = Braintree::ClientToken.generate
   client_token = decode_client_token(raw_client_token)
 
-  url = client_token["braintree_api"]["url"] + "/tokens"
-  token = client_token["braintree_api"]["access_token"]
-  payload = {
-    :type => "plaid_public_token",
-    :public_token => "good",
-    :account_id => "plaid_account_id",
-    :ownership_type => "business",
-    :business_name => "PayPal, Inc.",
-    :billing_address => {
-      :street_address => "123 Ave",
-      :region => "CA",
-      :locality => "San Francisco",
-      :postal_code => "94112"
-    },
-    :ach_mandate => {
-      :text => "cl mandate text"
+  url = client_token["graphQL"]["url"]
+  date = client_token["graphQL"]["date"]
+  token = client_token["authorizationFingerprint"]
+
+  definition = <<-GRAPHQL
+mutation TokenizeUsBankLogin($input: TokenizeUsBankLoginInput!) {
+  tokenizeUsBankLogin(input: $input) {
+    paymentMethod {
+      id
+    }
+  }
+}
+      GRAPHQL
+  variables = {
+    input: {
+      usBankLogin: {
+        achMandate: "cl mandate text",
+        publicToken: "good",
+        accountId: "plaid_account_id",
+        accountType: "CHECKING",
+        businessOwner: {
+          businessName: "PayPal, Inc."
+        },
+        billingAddress: {
+          streetAddress: "123 Ave",
+          city: "San Francisco",
+          state: "CA",
+          zipCode: "94112"
+        }
+      }
     }
   }
-
-  json = _cosmos_post(token, url, payload)
-  json["data"]["id"]
-end
-
-def generate_valid_ideal_payment_nonce(amount = Braintree::Test::TransactionAmounts::Authorize)
-  raw_client_token = Braintree::ClientToken.generate(:merchant_account_id => "ideal_merchant_account")
-  client_token = decode_client_token(raw_client_token)
-  client = ClientApiHttp.new(
-    Braintree::Configuration.instantiate,
-    :authorization_fingerprint => client_token["authorizationFingerprint"],
-  )
-  config = JSON.parse(client.get_configuration.body)
-
-  token = client_token["braintree_api"]["access_token"]
-  url = client_token["braintree_api"]["url"] + "/ideal-payments"
   payload = {
-    :issuer => "RABONL2U",
-    :order_id => SpecHelper::DefaultOrderId,
-    :amount => amount,
-    :currency => "EUR",
-    :redirect_url => "https://braintree-api.com",
-    :route_id => config["ideal"]["routeId"]
+    query: definition,
+    variables: variables
   }
+  uri = URI::parse(url)
+  connection = Net::HTTP.new(uri.host, uri.port)
+  connection.use_ssl = false
+  response = connection.start do |http|
+    request = Net::HTTP::Post.new(uri.path)
+    request["Content-Type"] = "application/json"
+    request["Braintree-Version"] = date
+    request["Authorization"] = "Bearer #{token}"
+    request.body = payload.to_json
+    http.request(request)
+  end
 
-  json = _cosmos_post(token, url, payload)
-  json["data"]["id"]
+  JSON.parse(response.body)[:data][:tokenizeUsBankLogin][:paymentMethod][:id]
 end
 
 def sample(arr)
@@ -146,23 +156,6 @@ def generate_invalid_us_bank_account_nonce
   nonce += "_xxx"
 end
 
-def _cosmos_post(token, url, payload)
-  uri = URI::parse(url)
-  connection = Net::HTTP.new(uri.host, uri.port)
-  connection.use_ssl = true
-  connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
-  resp = connection.start do |http|
-    request = Net::HTTP::Post.new(uri.path)
-    request["Content-Type"] = "application/json"
-    request["Braintree-Version"] = "2016-10-07"
-    request["Authorization"] = "Bearer #{token}"
-    request.body = payload.to_json
-    http.request(request)
-  end
-
-  JSON.parse(resp.body)
-end
-
 class ClientApiHttp
   attr_reader :config, :options
 

data/spec/integration/braintree/credit_card_spec.rb

@@ -246,6 +246,7 @@ describe Braintree::CreditCard do
       three_d_secure_info.eci_flag.should == "05"
       three_d_secure_info.three_d_secure_version.should == "1.0.2"
       three_d_secure_info.ds_transaction_id.should == nil
+      three_d_secure_info.three_d_secure_authentication_id.should_not be_nil
     end
 
     it "adds credit card with billing address to customer" do
@@ -1274,7 +1275,7 @@ describe Braintree::CreditCard do
         Braintree::CreditCard.create!(
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "01/2015"
+          :expiration_date => "01/#{Time.now.year - 3}"
         )
       end
 

data/spec/integration/braintree/credit_card_verification_spec.rb

@@ -161,6 +161,7 @@ describe Braintree::CreditCardVerification, "search" do
       found_verification = Braintree::CreditCardVerification.find(credit_card_verification.id)
 
       found_verification.should == credit_card_verification
+      found_verification.graphql_id.should_not be_nil
     end
 
     it "raises a NotFoundError exception if verification cannot be found" do

data/spec/integration/braintree/customer_spec.rb

@@ -889,6 +889,7 @@ describe Braintree::Customer do
 
       customer = Braintree::Customer.find(result.customer.id)
       customer.id.should == result.customer.id
+      customer.graphql_id.should_not be_nil
       customer.first_name.should == "Joe"
       customer.last_name.should == "Cool"
     end
@@ -1015,6 +1016,7 @@ describe Braintree::Customer do
       android_pay_card.should be_a Braintree::AndroidPayCard
       android_pay_card.token.should_not be_nil
       android_pay_card.expiration_year.should_not be_nil
+      android_pay_card.is_network_tokenized?.should == false
     end
 
     it "returns associated android pay network tokens" do
@@ -1030,6 +1032,7 @@ describe Braintree::Customer do
       android_pay_card.should be_a Braintree::AndroidPayCard
       android_pay_card.token.should_not be_nil
       android_pay_card.expiration_year.should_not be_nil
+      android_pay_card.is_network_tokenized?.should == true
     end
 
     it "returns associated amex express checkout cards" do

data/spec/integration/braintree/dispute_search_spec.rb

@@ -74,7 +74,7 @@ describe Braintree::Dispute, "search" do
         ]
       end
 
-      expect(collection.disputes.count).to eq(2)
+      expect(collection.disputes.count).to be >= 2
       dispute = collection.disputes.first
     end
 

data/spec/integration/braintree/dispute_spec.rb

@@ -186,6 +186,7 @@ describe Braintree::Dispute do
       dispute.amount_disputed.should == 31.0
       dispute.amount_won.should == 0.0
       dispute.id.should == "open_dispute"
+      dispute.graphql_id.should_not be_nil
       dispute.status.should == Braintree::Dispute::Status::Open
       dispute.transaction.amount.should == 31.0
       dispute.transaction.id.should == "open_disputed_transaction"

data/spec/integration/braintree/payment_method_nonce_spec.rb

@@ -84,10 +84,14 @@ describe Braintree::PaymentMethodNonce do
     end
 
     it "return paypal details if details exist" do
-      result = Braintree::PaymentMethodNonce.find("fake-google-pay-paypal-nonce")
-
+      result = Braintree::PaymentMethodNonce.find("fake-paypal-one-time-nonce")
       nonce = result.payment_method_nonce
 
+      nonce.details.fetch(:cobranded_card_label).should_not be_nil
+      nonce.details.fetch(:shipping_option_id).should_not be_nil
+      nonce.details.fetch(:billing_address).fetch(:recipient_name).should_not be_nil
+      nonce.details.fetch(:shipping_address).fetch(:recipient_name).should_not be_nil
+
       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

data/spec/integration/braintree/payment_method_spec.rb

@@ -121,6 +121,7 @@ describe Braintree::PaymentMethod do
       android_pay_card.expiration_year.to_i.should > 0
       android_pay_card.default.should == true
       android_pay_card.image_url.should =~ /android_pay/
+      android_pay_card.is_network_tokenized?.should == false
       android_pay_card.source_card_type.should == Braintree::CreditCard::CardType::Discover
       android_pay_card.source_card_last_4.should == "1111"
       android_pay_card.google_transaction_id.should == "google_transaction_id"
@@ -148,6 +149,7 @@ describe Braintree::PaymentMethod do
       android_pay_card.expiration_year.to_i.should > 0
       android_pay_card.default.should == true
       android_pay_card.image_url.should =~ /android_pay/
+      android_pay_card.is_network_tokenized?.should == true
       android_pay_card.source_card_type.should == Braintree::CreditCard::CardType::MasterCard
       android_pay_card.source_card_last_4.should == "4444"
       android_pay_card.google_transaction_id.should == "google_transaction_id"
@@ -727,24 +729,6 @@ describe Braintree::PaymentMethod do
         found_paypal_account.payer_id.should_not be_nil
       end
 
-      it "creates a billing agreement payment method from a refresh token without upgrading" do
-        customer = Braintree::Customer.create.customer
-        result = Braintree::PaymentMethod.create(
-          :customer_id => customer.id,
-          :paypal_refresh_token => "some_future_payment_token",
-          :paypal_vault_without_upgrade => true,
-        )
-
-        result.should be_success
-        result.payment_method.should be_a(Braintree::PayPalAccount)
-        result.payment_method.billing_agreement_id.should be_nil
-        token = result.payment_method.token
-
-        found_paypal_account = Braintree::PayPalAccount.find(token)
-        found_paypal_account.should_not be_nil
-        found_paypal_account.billing_agreement_id.should be_nil
-      end
-
       it "does not create a payment method from an unvalidated onetime paypal account nonce" do
         customer = Braintree::Customer.create.customer
         nonce = nonce_for_paypal_account(:access_token => "PAYPAL_ACCESS_TOKEN")
@@ -1017,6 +1001,7 @@ describe Braintree::PaymentMethod do
         android_pay_card.expiration_year.to_i.should > 0
         android_pay_card.default.should == true
         android_pay_card.image_url.should =~ /android_pay/
+        android_pay_card.is_network_tokenized?.should == false
         android_pay_card.source_card_type.should == Braintree::CreditCard::CardType::Discover
         android_pay_card.source_card_last_4.should == "1111"
         android_pay_card.google_transaction_id.should == "google_transaction_id"
@@ -1044,6 +1029,7 @@ describe Braintree::PaymentMethod do
         android_pay_card.expiration_year.to_i.should > 0
         android_pay_card.default.should == true
         android_pay_card.image_url.should =~ /android_pay/
+        android_pay_card.is_network_tokenized?.should == true
         android_pay_card.source_card_type.should == Braintree::CreditCard::CardType::MasterCard
         android_pay_card.source_card_last_4.should == "4444"
         android_pay_card.google_transaction_id.should == "google_transaction_id"

data/spec/integration/braintree/transaction_spec.rb

@@ -1706,6 +1706,7 @@ describe Braintree::Transaction do
         android_pay_details.expiration_year.to_i.should > 0
         android_pay_details.google_transaction_id.should == "google_transaction_id"
         android_pay_details.image_url.should_not be_nil
+        android_pay_details.is_network_tokenized?.should == false
         android_pay_details.token.should be_nil
         android_pay_details.prepaid.should_not be_nil
         android_pay_details.healthcare.should_not be_nil
@@ -1737,6 +1738,7 @@ describe Braintree::Transaction do
         android_pay_details.expiration_year.to_i.should > 0
         android_pay_details.google_transaction_id.should == "google_transaction_id"
         android_pay_details.image_url.should_not be_nil
+        android_pay_details.is_network_tokenized?.should == false
         android_pay_details.token.should_not be_nil
       end
 
@@ -1759,6 +1761,7 @@ describe Braintree::Transaction do
         android_pay_details.expiration_month.to_i.should > 0
         android_pay_details.expiration_year.to_i.should > 0
         android_pay_details.google_transaction_id.should == "google_transaction_id"
+        android_pay_details.is_network_tokenized?.should == true
       end
 
       it "can create a transaction with a fake amex express checkout card nonce" do
@@ -2085,6 +2088,7 @@ describe Braintree::Transaction do
 
         result = Braintree::Transaction.create(
           :type => "sale",
+          :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
           :amount => Braintree::Test::TransactionAmounts::Authorize,
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
@@ -2121,7 +2125,8 @@ describe Braintree::Transaction do
         result.transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::ThreeDSecure
       end
 
-      it "can create a transaction without a three_d_secure token" do
+
+      it "can create a transaction without a three_d_secure_authentication_id" do
         result = Braintree::Transaction.create(
           :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
           :type => "sale",
@@ -2134,41 +2139,174 @@ describe Braintree::Transaction do
         result.success?.should == true
       end
 
-      it "returns an error if sent a nil three_d_secure token" do
-        result = Braintree::Transaction.create(
-          :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :credit_card => {
+      context "with three_d_secure_authentication_id" do
+        it "can create a transaction with a three_d_secure_authentication_id" do
+          three_d_secure_authentication_id = SpecHelper.create_3ds_verification(
+            SpecHelper::ThreeDSecureMerchantAccountId,
             :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-          :three_d_secure_token => nil
-        )
-        result.success?.should == false
-        result.errors.for(:transaction).on(:three_d_secure_token)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureTokenIsInvalid
+            :expiration_month => "12",
+            :expiration_year => "2022"
+          )
+
+          result = Braintree::Transaction.create(
+            :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "12/22",
+            },
+            :three_d_secure_authentication_id => three_d_secure_authentication_id
+          )
+
+          result.success?.should == true
+        end
+        it "returns an error if sent a nil three_d_secure_authentication_id" do
+          result = Braintree::Transaction.create(
+            :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "12/12",
+            },
+            :three_d_secure_authentication_id => nil
+          )
+          result.success?.should == false
+          result.errors.for(:transaction).on(:three_d_secure_authentication_id)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureAuthenticationIdIsInvalid
+        end
+        it "returns an error if merchant_account in the payment_method does not match with 3ds data" do
+          three_d_secure_authentication_id = SpecHelper.create_3ds_verification(
+            SpecHelper::ThreeDSecureMerchantAccountId,
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "12",
+            :expiration_year => "2012"
+          )
+
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::MasterCard,
+              :expiration_date => "12/12",
+            },
+            :three_d_secure_authentication_id => three_d_secure_authentication_id
+          )
+          result.success?.should == false
+          result.errors.for(:transaction).on(:three_d_secure_authentication_id)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureTransactionPaymentMethodDoesntMatchThreeDSecureAuthenticationPaymentMethod
+        end
+        it "returns an error if 3ds lookup data does not match txn data" do
+          three_d_secure_authentication_id = SpecHelper.create_3ds_verification(
+            SpecHelper::ThreeDSecureMerchantAccountId,
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "12",
+            :expiration_year => "2012"
+          )
+
+          result = Braintree::Transaction.create(
+            :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::MasterCard,
+              :expiration_date => "12/12",
+            },
+            :three_d_secure_authentication_id => three_d_secure_authentication_id
+          )
+          result.success?.should == false
+          result.errors.for(:transaction).on(:three_d_secure_authentication_id)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureTransactionPaymentMethodDoesntMatchThreeDSecureAuthenticationPaymentMethod
+        end
+        it "returns an error if three_d_secure_authentication_id is supplied with three_d_secure_pass_thru" do
+          three_d_secure_authentication_id = SpecHelper.create_3ds_verification(
+            SpecHelper::ThreeDSecureMerchantAccountId,
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "12",
+            :expiration_year => "2012"
+          )
+          result = Braintree::Transaction.create(
+            :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "12/12",
+            },
+            :three_d_secure_authentication_id => three_d_secure_authentication_id,
+            :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 => "2",
+              :ds_transaction_id => "some_ds_id",
+            }
+          )
+          result.success?.should == false
+          result.errors.for(:transaction).on(:three_d_secure_authentication_id)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureAuthenticationIdWithThreeDSecurePassThruIsInvalid
+        end
       end
 
-      it "returns an error if 3ds lookup data does not match txn data" do
-        three_d_secure_token = SpecHelper.create_3ds_verification(
-          SpecHelper::ThreeDSecureMerchantAccountId,
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_month => "12",
-          :expiration_year => "2012"
-        )
+      context "with three_d_secure_token" do
+        it "can create a transaction with a three_d_secure token" do
+          three_d_secure_token = SpecHelper.create_3ds_verification(
+            SpecHelper::ThreeDSecureMerchantAccountId,
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "12",
+            :expiration_year => "2012"
+          )
 
-        result = Braintree::Transaction.create(
-          :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::MasterCard,
-            :expiration_date => "12/12",
-          },
-          :three_d_secure_token => three_d_secure_token
-        )
-        result.success?.should == false
-        result.errors.for(:transaction).on(:three_d_secure_token)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureTransactionDataDoesntMatchVerify
+          result = Braintree::Transaction.create(
+            :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "12/12",
+            },
+            :three_d_secure_token => three_d_secure_token
+          )
+
+          result.success?.should == true
+        end
+
+        it "returns an error if sent a nil three_d_secure token" do
+          result = Braintree::Transaction.create(
+            :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "12/12",
+            },
+            :three_d_secure_token => nil
+          )
+          result.success?.should == false
+          result.errors.for(:transaction).on(:three_d_secure_token)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureTokenIsInvalid
+        end
+
+        it "returns an error if 3ds lookup data does not match txn data" do
+          three_d_secure_token = SpecHelper.create_3ds_verification(
+            SpecHelper::ThreeDSecureMerchantAccountId,
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "12",
+            :expiration_year => "2012"
+          )
+
+          result = Braintree::Transaction.create(
+            :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::MasterCard,
+              :expiration_date => "12/12",
+            },
+            :three_d_secure_token => three_d_secure_token
+          )
+          result.success?.should == false
+          result.errors.for(:transaction).on(:three_d_secure_token)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureTransactionDataDoesntMatchVerify
+        end
       end
 
       it "can create a transaction with a three_d_secure_pass_thru" do
@@ -2632,6 +2770,36 @@ describe Braintree::Transaction do
           result.success?.should == false
           result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::CannotRefundUnlessSettled
         end
+
+        it "handles soft declined refund authorizations" do
+          transaction = Braintree::Transaction.sale!(
+            :amount => "9000.00",
+            :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+            :options => {
+              :submit_for_settlement => true
+            }
+          )
+          config = Braintree::Configuration.instantiate
+          response = config.http.put("#{config.base_merchant_path}/transactions/#{transaction.id}/settle")
+          result = Braintree::Transaction.refund(transaction.id, :amount => "2046.00")
+          result.success?.should == false
+          result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::RefundAuthSoftDeclined
+        end
+
+        it "handles hard declined refund authorizations" do
+          transaction = Braintree::Transaction.sale!(
+            :amount => "9000.00",
+            :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+            :options => {
+              :submit_for_settlement => true
+            }
+          )
+          config = Braintree::Configuration.instantiate
+          response = config.http.put("#{config.base_merchant_path}/transactions/#{transaction.id}/settle")
+          result = Braintree::Transaction.refund(transaction.id, :amount => "2009.00")
+          result.success?.should == false
+          result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::RefundAuthHardDeclined
+        end
       end
 
       context "handling errors" do
@@ -5088,6 +5256,71 @@ describe Braintree::Transaction do
         result.errors.for(:transaction).on(:amount)[0].code.should == Braintree::ErrorCodes::Transaction::SettlementAmountIsLessThanServiceFeeAmount
       end
     end
+
+    it "succeeds when level 2 data is provided" do
+      result = Braintree::Transaction.sale(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :merchant_account_id => SpecHelper::FakeAmexDirectMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::AmexPayWithPoints::Success,
+          :expiration_date => "05/2009"
+        },
+        :options => {
+          :amex_rewards => {
+            :request_id => "ABC123",
+            :points => "1000",
+            :currency_amount => "10.00",
+            :currency_iso_code => "USD"
+          }
+        }
+      )
+      result.success?.should == true
+
+      result = Braintree::Transaction.submit_for_settlement(result.transaction.id, nil, :tax_amount => "2.00", :tax_exempt => false, :purchase_order_number => "0Rd3r#")
+      result.success?.should == true
+      result.transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
+    end
+
+    it "succeeds when level 3 data is provided" do
+      result = Braintree::Transaction.sale(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :merchant_account_id => SpecHelper::FakeAmexDirectMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::AmexPayWithPoints::Success,
+          :expiration_date => "05/2009"
+        },
+        :options => {
+          :amex_rewards => {
+            :request_id => "ABC123",
+            :points => "1000",
+            :currency_amount => "10.00",
+            :currency_iso_code => "USD"
+          }
+        }
+      )
+      result.success?.should == true
+
+      result = Braintree::Transaction.submit_for_settlement(
+        result.transaction.id,
+        nil,
+        :discount_amount => "2.00",
+        :shipping_amount => "1.23",
+        :ships_from_postal_code => "90210",
+        :line_items => [
+          {
+            :quantity => 1,
+            :unit_amount => 1,
+            :name => "New line item",
+            :kind => "debit",
+            :total_amount => "18.00",
+            :discount_amount => "12.00",
+            :tax_amount => "0",
+          },
+        ]
+      )
+      result.success?.should == true
+      result.transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
+    end
   end
 
   describe "self.submit_for_settlement!" do
@@ -5884,6 +6117,7 @@ describe Braintree::Transaction do
       created_transaction = result.transaction
       found_transaction = Braintree::Transaction.find(created_transaction.id)
       found_transaction.should == created_transaction
+      found_transaction.graphql_id.should_not be_nil
     end
 
     it "finds the vaulted transaction with the given id" do

data/spec/spec_helper.rb

@@ -110,7 +110,7 @@ unless defined?(SPEC_HELPER_LOADED)
     def self.create_3ds_verification(merchant_account_id, params)
       config = Braintree::Configuration.instantiate
       response = config.http.post("#{config.base_merchant_path}/three_d_secure/create_verification/#{merchant_account_id}", :three_d_secure_verification => params)
-      response[:three_d_secure_verification][:three_d_secure_token]
+      response[:three_d_secure_verification][:three_d_secure_authentication_id]
     end
 
     def self.create_merchant(params={})

data/spec/unit/braintree/three_d_secure_info_spec.rb

@@ -12,6 +12,7 @@ describe Braintree::ThreeDSecureInfo do
       :eci_flag => "06",
       :three_d_secure_version => "1.0.2",
       :ds_transaction_id => "dstrxid",
+      :three_d_secure_authentication_id => "auth_id",
     )
   }
 
@@ -26,12 +27,13 @@ describe Braintree::ThreeDSecureInfo do
       three_d_secure_info.eci_flag.should == "06"
       three_d_secure_info.three_d_secure_version.should == "1.0.2"
       three_d_secure_info.ds_transaction_id.should == "dstrxid"
+      three_d_secure_info.three_d_secure_authentication_id.should == "auth_id"
     end
   end
 
   describe "inspect" do
     it "prints the attributes" do
-      three_d_secure_info.inspect.should == %(#<ThreeDSecureInfo enrolled: "Y", liability_shifted: true, liability_shift_possible: true, status: "authenticate_successful", cavv: "cavvvalue", xid: "xidvalue", eci_flag: "06", three_d_secure_version: "1.0.2", ds_transaction_id: "dstrxid">)
+      three_d_secure_info.inspect.should == %(#<ThreeDSecureInfo enrolled: "Y", liability_shifted: true, liability_shift_possible: true, status: "authenticate_successful", cavv: "cavvvalue", xid: "xidvalue", eci_flag: "06", three_d_secure_version: "1.0.2", ds_transaction_id: "dstrxid", three_d_secure_authentication_id: "auth_id">)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: braintree
 version: !ruby/object:Gem::Version
-  version: 2.100.0
+  version: 2.101.0
 platform: ruby
 authors:
 - Braintree
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-28 00:00:00.000000000 Z
+date: 2020-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -320,7 +320,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Braintree Gateway Ruby Client Library