braintree 4.22.0 → 4.23.0

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

@@ -140,51 +140,242 @@ describe Braintree::ClientToken do
       expect(customer.credit_cards.select { |c| c.bin == "400551" }[0]).to be_default
     end
 
-    it "can pass fail_on_duplicate_payment_method" do
-      config = Braintree::Configuration.instantiate
-      result = Braintree::Customer.create
-      customer_id = result.customer.id
-      raw_client_token = Braintree::ClientToken.generate(
-        :customer_id => customer_id,
-      )
-      client_token = decode_client_token(raw_client_token)
+    context "fail on duplicate payment methods check" do
+      context "card exists for a different customer" do
+        before(:each) do
+          config = Braintree::Configuration.instantiate
+          result = Braintree::Customer.create
+          customer_id = result.customer.id
+          raw_client_token = Braintree::ClientToken.generate(
+            :customer_id => customer_id,
+          )
+          client_token = decode_client_token(raw_client_token)
 
-      http = ClientApiHttp.new(
-        config,
-        :authorization_fingerprint => client_token["authorizationFingerprint"],
-        :shared_customer_identifier => "fake_identifier",
-        :shared_customer_identifier_type => "testing",
-      )
+          http = ClientApiHttp.new(
+            config,
+            :authorization_fingerprint => client_token["authorizationFingerprint"],
+            :shared_customer_identifier => "fake_identifier",
+            :shared_customer_identifier_type => "testing",
+          )
+
+          response = http.add_payment_method(
+            :credit_card => {
+              :number => "4111111111111111",
+              :expiration_month => "11",
+              :expiration_year => "2099"
+            },
+          )
+          expect(response.code).to eq("201")
+        end
 
-      response = http.add_payment_method(
-        :credit_card => {
-          :number => "4111111111111111",
-          :expiration_month => "11",
-          :expiration_year => "2099"
-        },
-      )
+        it "does not create when fail_on_duplicate_payment_method = true and fail_on_duplicate_payment_method_for_customer = false" do
+          result = Braintree::Customer.create
+          second_raw_client_token = Braintree::ClientToken.generate(
+            :customer_id => result.customer_id,
+            :options => {
+              :fail_on_duplicate_payment_method => true,
+              :fail_on_duplicate_payment_method_for_customer => false
+            },
+          )
+          second_client_token = decode_client_token(second_raw_client_token)
+
+          http.fingerprint = second_client_token["authorizationFingerprint"]
+
+          response = http.add_payment_method(
+            :credit_card => {
+              :number => "4111111111111111",
+              :expiration_month => "11",
+              :expiration_year => "2099"
+            },
+          )
+          expect(response.code).to eq("201")
+        end
 
-      expect(response.code).to eq("201")
+        it "creates when fail_on_duplicate_payment_method = false and fail_on_duplicate_payment_method_for_customer = true" do
+          result = Braintree::Customer.create
+          second_raw_client_token = Braintree::ClientToken.generate(
+            :customer_id => result.customer_id,
+            :options => {
+              :fail_on_duplicate_payment_method => true,
+              :fail_on_duplicate_payment_method_for_customer => false
+            },
+          )
+          second_client_token = decode_client_token(second_raw_client_token)
+
+          http.fingerprint = second_client_token["authorizationFingerprint"]
+
+          response = http.add_payment_method(
+            :credit_card => {
+              :number => "4111111111111111",
+              :expiration_month => "11",
+              :expiration_year => "2099"
+            },
+          )
+          expect(response.code).to eq("201")
+        end
 
-      second_raw_client_token = Braintree::ClientToken.generate(
-        :customer_id => customer_id,
-        :options => {
-          :fail_on_duplicate_payment_method => true
-        },
-      )
-      second_client_token = decode_client_token(second_raw_client_token)
+        it "does not create fail_on_duplicate_payment_method = true and fail_on_duplicate_payment_method_for_customer = true" do
+          result = Braintree::Customer.create
+          second_raw_client_token = Braintree::ClientToken.generate(
+            :customer_id => result.customer_id,
+            :options => {
+              :fail_on_duplicate_payment_method => true,
+              :fail_on_duplicate_payment_method_for_customer => true
+            },
+          )
+          second_client_token = decode_client_token(second_raw_client_token)
+
+          http.fingerprint = second_client_token["authorizationFingerprint"]
+
+          response = http.add_payment_method(
+            :credit_card => {
+              :number => "4111111111111111",
+              :expiration_month => "11",
+              :expiration_year => "2099"
+            },
+          )
+          expect(response.code).to eq("422")
+        end
 
-      http.fingerprint = second_client_token["authorizationFingerprint"]
+        it "creates when fail_on_duplicate_payment_method = false and fail_on_duplicate_payment_method_for_customer = false" do
+          result = Braintree::Customer.create
+          second_raw_client_token = Braintree::ClientToken.generate(
+            :customer_id => result.customer_id,
+            :options => {
+              :fail_on_duplicate_payment_method => false,
+              :fail_on_duplicate_payment_method_for_customer => false
+            },
+          )
+          second_client_token = decode_client_token(second_raw_client_token)
+
+          http.fingerprint = second_client_token["authorizationFingerprint"]
+
+          response = http.add_payment_method(
+            :credit_card => {
+              :number => "4111111111111111",
+              :expiration_month => "11",
+              :expiration_year => "2099"
+            },
+          )
+          expect(response.code).to eq("201")
+        end
+      end
 
-      response = http.add_payment_method(
-        :credit_card => {
-          :number => "4111111111111111",
-          :expiration_month => "11",
-          :expiration_year => "2099"
-        },
-      )
+      context "card exists for a same customer" do
+        before(:each) do
+          config = Braintree::Configuration.instantiate
+          result = Braintree::Customer.create
+          let(:customer_id) { result.customer.id }
+          raw_client_token = Braintree::ClientToken.generate(
+            :customer_id => customer_id,
+          )
+          client_token = decode_client_token(raw_client_token)
 
-      expect(response.code).to eq("422")
+          http = ClientApiHttp.new(
+            config,
+            :authorization_fingerprint => client_token["authorizationFingerprint"],
+            :shared_customer_identifier => "fake_identifier",
+            :shared_customer_identifier_type => "testing",
+          )
+
+          response = http.add_payment_method(
+            :credit_card => {
+              :number => "4111111111111111",
+              :expiration_month => "11",
+              :expiration_year => "2099"
+            },
+          )
+          expect(response.code).to eq("201")
+        end
+
+        it "creates when fail_on_duplicate_payment_method = true and fail_on_duplicate_payment_method_for_customer = false for same customer" do
+          second_raw_client_token = Braintree::ClientToken.generate(
+            :customer_id => customer_id,
+            :options => {
+              :fail_on_duplicate_payment_method => true,
+              :fail_on_duplicate_payment_method_for_customer => false
+            },
+          )
+          second_client_token = decode_client_token(second_raw_client_token)
+
+          http.fingerprint = second_client_token["authorizationFingerprint"]
+
+          response = http.add_payment_method(
+            :credit_card => {
+              :number => "4111111111111111",
+              :expiration_month => "11",
+              :expiration_year => "2099"
+            },
+          )
+          expect(response.code).to eq("201")
+        end
+
+        it "does not create when fail_on_duplicate_payment_method = false and fail_on_duplicate_payment_method_for_customer = true for same customer" do
+          second_raw_client_token = Braintree::ClientToken.generate(
+            :customer_id => customer_id,
+            :options => {
+              :fail_on_duplicate_payment_method => false,
+              :fail_on_duplicate_payment_method_for_customer => true
+            },
+          )
+          second_client_token = decode_client_token(second_raw_client_token)
+
+          http.fingerprint = second_client_token["authorizationFingerprint"]
+
+          response = http.add_payment_method(
+            :credit_card => {
+              :number => "4111111111111111",
+              :expiration_month => "11",
+              :expiration_year => "2099"
+            },
+          )
+          expect(response.code).to eq("422")
+        end
+
+        it "does not create when fail_on_duplicate_payment_method = true and fail_on_duplicate_payment_method_for_customer = true for same customer" do
+          second_raw_client_token = Braintree::ClientToken.generate(
+            :customer_id => customer_id,
+            :options => {
+              :fail_on_duplicate_payment_method => true,
+              :fail_on_duplicate_payment_method_for_customer => false
+            },
+          )
+          second_client_token = decode_client_token(second_raw_client_token)
+
+          http.fingerprint = second_client_token["authorizationFingerprint"]
+
+          response = http.add_payment_method(
+            :credit_card => {
+              :number => "4111111111111111",
+              :expiration_month => "11",
+              :expiration_year => "2099"
+            },
+          )
+          expect(response.code).to eq("422")
+        end
+
+        it "creates when fail_on_duplicate_payment_method = false and fail_on_duplicate_payment_method_for_customer = false for same customer" do
+          second_raw_client_token = Braintree::ClientToken.generate(
+            :customer_id => customer_id,
+            :options => {
+              :fail_on_duplicate_payment_method => false,
+              :fail_on_duplicate_payment_method_for_customer => false
+            },
+          )
+          second_client_token = decode_client_token(second_raw_client_token)
+
+          http.fingerprint = second_client_token["authorizationFingerprint"]
+
+          response = http.add_payment_method(
+            :credit_card => {
+              :number => "4111111111111111",
+              :expiration_month => "11",
+              :expiration_year => "2099"
+            },
+          )
+          expect(response.code).to eq("201")
+        end
+      end
     end
 
     it "can pass merchant_account_id" do

data/spec/integration/braintree/credit_card_spec.rb

@@ -622,7 +622,7 @@ describe Braintree::CreditCard do
           :expiration_year => "2099",
           :options => {
             :verify_card => true,
-            :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+            :verification_merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
             :verification_account_type => "debit",
           },
         )
@@ -1113,7 +1113,7 @@ describe Braintree::CreditCard do
           :options => {
             :verify_card => true,
             :verification_account_type => "debit",
-            :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+            :verification_merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
           },
         )
         expect(update_result).to be_success

data/spec/integration/braintree/credit_card_verification_spec.rb

@@ -157,7 +157,7 @@ describe Braintree::CreditCardVerification, "search" do
           :number => Braintree::Test::CreditCardNumbers::Hiper
         },
         :options => {
-          :merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+          :merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
           :account_type => "debit",
         },
       )

data/spec/integration/braintree/customer_spec.rb

@@ -620,7 +620,7 @@ describe Braintree::Customer do
           :credit_card => {
             :options => {
               :verify_card => true,
-              :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+              :verification_merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
               :verification_account_type => "debit",
             }
           },
@@ -1231,6 +1231,27 @@ describe Braintree::Customer do
       expect(result.errors.for(:customer).for(:credit_card).on(:number)[0].message).to eq("Duplicate card exists in the vault.")
     end
 
+    it "does not update customer with duplicate payment method if fail_on_payment_method_for_customer option set" do
+      customer = Braintree::Customer.create!(
+        :credit_card => {
+          :number => 4111111111111111,
+          :expiration_date => "05/2010",
+        },
+      )
+      result = Braintree::Customer.update(
+        customer.id,
+        :credit_card => {
+          :number => 4111111111111111,
+          :expiration_date => "05/2010",
+          :options=> {
+            :fail_on_duplicate_payment_method_for_customer => true
+          }
+        },
+      )
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:customer).for(:credit_card).on(:number)[0].message).to eq("Duplicate card exists in the vault for the customer.")
+    end
+
     it "updates the default payment method" do
       customer = Braintree::Customer.create!(
         :first_name => "Joe",
@@ -1664,7 +1685,7 @@ describe Braintree::Customer do
             :expiration_date => "06/2013",
             :options => {
               :verify_card => true,
-              :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+              :verification_merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
               :verification_account_type => "debit",
             },
           },

data/spec/integration/braintree/payment_method_spec.rb

@@ -427,6 +427,33 @@ describe Braintree::PaymentMethod do
       expect(result.errors.first.code).to eq("81724")
     end
 
+    it "respects fail_on_duplicate_payment_method_for_customer when included outside of the nonce" do
+      customer = Braintree::Customer.create!
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => 4111111111111111,
+        :expiration_date => "05/2012",
+      )
+      expect(result).to be_success
+
+      nonce = nonce_for_new_payment_method(
+        :credit_card => {
+          :number => 4111111111111111,
+          :expiration_date => "05/2012"
+        },
+      )
+      result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id,
+        :options => {
+          :fail_on_duplicate_payment_method_for_customer => true
+        },
+      )
+
+      expect(result).not_to be_success
+      expect(result.errors.first.code).to eq("81763")
+    end
+
     it "allows passing the billing address outside of the nonce" do
       config = Braintree::Configuration.instantiate
       customer = Braintree::Customer.create.customer
@@ -659,7 +686,7 @@ describe Braintree::PaymentMethod do
           :customer_id => customer.id,
           :options => {
             :verify_card => true,
-            :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+            :verification_merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
             :verification_account_type => "debit",
           },
         )
@@ -776,7 +803,7 @@ describe Braintree::PaymentMethod do
           :expiration_date => "06/2013",
           :options => {
             :verify_card => true,
-            :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+            :verification_merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
             :verification_account_type => "debit",
           },
         )

data/spec/integration/braintree/samsung_pay_card_spec.rb

@@ -1,7 +1,9 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
 
-describe Braintree::SamsungPayCard do
+# NEXT_MAJOR_VERSION remove these tests
+# SamsungPayCard has been deprecated
+xdescribe Braintree::SamsungPayCard do
   it "can create from payment method nonce" do
     customer = Braintree::Customer.create!
 

data/spec/integration/braintree/transaction_spec.rb

@@ -4860,27 +4860,6 @@ describe Braintree::Transaction do
     end
 
     context "external vault" do
-      it "returns a validation error if used with an unsupported instrument type" do
-        customer = Braintree::Customer.create!
-        result = Braintree::PaymentMethod.create(
-          :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
-          :customer_id => customer.id,
-        )
-        payment_method_token = result.payment_method.token
-
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :customer_id => customer.id,
-          :payment_method_token => payment_method_token,
-          :external_vault => {
-            :status => Braintree::Transaction::ExternalVault::Status::WillVault,
-          },
-          :amount => "10.00",
-        )
-        expect(result.success?).to eq(false)
-        expect(result.errors.for(:transaction)[0].code).to eq(Braintree::ErrorCodes::Transaction::PaymentInstrumentWithExternalVaultIsInvalid)
-      end
-
       it "reject invalid status" do
         result = Braintree::Transaction.create(
           :type => "sale",

data/spec/unit/braintree/client_token_spec.rb

@@ -23,7 +23,7 @@ module Braintree
     end
 
     context "adding credit_card options with no customer ID" do
-      %w(verify_card fail_on_duplicate_payment_method make_default).each do |option_name|
+      %w(verify_card fail_on_duplicate_payment_method make_default fail_on_duplicate_payment_method_for_customer).each do |option_name|
         it "raises an ArgumentError if #{option_name} is present" do
           expect do
             Braintree::ClientToken.generate(

data/spec/unit/braintree/credit_card_spec.rb

@@ -25,7 +25,7 @@ describe Braintree::CreditCard do
         :payment_method_nonce,
         {:external_vault=>[:network_transaction_id]},
         {:options => match_array([:make_default, :skip_advanced_fraud_checking, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, # NEXT_MAJOR_VERSION Remove this attribute
-          :fail_on_duplicate_payment_method, :verification_account_type, :verification_currency_iso_code])},
+          :fail_on_duplicate_payment_method, :fail_on_duplicate_payment_method_for_customer, :verification_account_type, :verification_currency_iso_code])},
         {:billing_address => [
           :company,
           :country_code_alpha2,
@@ -73,7 +73,7 @@ describe Braintree::CreditCard do
         :payment_method_nonce,
         {:external_vault=>[:network_transaction_id]},
         {:options => match_array([:make_default, :skip_advanced_fraud_checking, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, # NEXT_MAJOR_VERSION Remove this attribute
-          :fail_on_duplicate_payment_method, :verification_account_type, :verification_currency_iso_code])},
+          :fail_on_duplicate_payment_method, :fail_on_duplicate_payment_method_for_customer, :verification_account_type, :verification_currency_iso_code])},
         {:billing_address => [
           :company,
           :country_code_alpha2,

data/spec/unit/braintree/customer_spec.rb

@@ -209,6 +209,7 @@ describe Braintree::Customer do
             :verification_amount,
             :venmo_sdk_session, # NEXT_MAJOR_VERSION Remove this attribute
             :fail_on_duplicate_payment_method,
+            :fail_on_duplicate_payment_method_for_customer,
             :verification_account_type,
             :verification_currency_iso_code,
             :update_existing_token

data/spec/unit/braintree/local_payment_completed_spec.rb

@@ -51,6 +51,34 @@ describe Braintree::LocalPaymentCompleted do
       local_payment_completed = Braintree::LocalPaymentCompleted._new(params)
 
       expect(local_payment_completed.bic).to eq("a-bic")
+      expect(local_payment_completed.blik_aliases).to be_nil
+      expect(local_payment_completed.iban_last_chars).to eq("1234")
+      expect(local_payment_completed.payer_id).to eq("a-payer-id")
+      expect(local_payment_completed.payer_name).to eq("John Doe")
+      expect(local_payment_completed.payment_id).to eq("a-payment-id")
+      expect(local_payment_completed.payment_method_nonce).to eq("a-nonce")
+      expect(local_payment_completed.transaction).to be_nil
+    end
+
+    it "initializes the object with the appropriate attributes when blik_aliases is provided" do
+      params = {
+        bic: "a-bic",
+        blik_aliases: [
+          {
+            key: "an-alias-key",
+            label: "an-alias-label"
+          }
+        ],
+        iban_last_chars: "1234",
+        payer_id: "a-payer-id",
+        payer_name: "John Doe",
+        payment_id: "a-payment-id",
+        payment_method_nonce: "a-nonce",
+      }
+      local_payment_completed = Braintree::LocalPaymentCompleted._new(params)
+
+      expect(local_payment_completed.bic).to eq("a-bic")
+      expect(local_payment_completed.blik_aliases).to match_array([{key: "an-alias-key", label: "an-alias-label"}])
       expect(local_payment_completed.iban_last_chars).to eq("1234")
       expect(local_payment_completed.payer_id).to eq("a-payer-id")
       expect(local_payment_completed.payer_name).to eq("John Doe")

data/spec/unit/braintree/transaction/local_payment_details_spec.rb

@@ -4,6 +4,12 @@ describe Braintree::Transaction::LocalPaymentDetails do
   describe "initialize" do
     let(:params) do
       {
+        blik_aliases: [
+          {
+            key: "a-key",
+            label: "a-label"
+          }
+        ],
         capture_id: "a-capture-id",
         custom_field: "custom-field",
         debug_id: "debug-id",

data/spec/unit/braintree/webhook_notification_spec.rb

@@ -723,14 +723,35 @@ describe Braintree::WebhookNotification do
       expect(notification.kind).to eq(Braintree::WebhookNotification::Kind::LocalPaymentCompleted)
 
       local_payment_completed = notification.local_payment_completed
-      expect(local_payment_completed.payment_id).to eq("PAY-XYZ123")
+      expect(local_payment_completed.blik_aliases).to be_nil
       expect(local_payment_completed.payer_id).to eq("ABCPAYER")
+      expect(local_payment_completed.payment_id).to eq("PAY-XYZ123")
       expect(local_payment_completed.payment_method_nonce).to eq("ee257d98-de40-47e8-96b3-a6954ea7a9a4")
       expect(local_payment_completed.transaction.id).to eq("my_id")
       expect(local_payment_completed.transaction.status).to eq(Braintree::Transaction::Status::Authorized)
       expect(local_payment_completed.transaction.amount).to eq(49.99)
       expect(local_payment_completed.transaction.order_id).to eq("order4567")
     end
+
+    it "builds a sample notification for a local_payment webhook when funding source is blik one click" do
+      sample_notification = Braintree::WebhookTesting.sample_notification(
+        Braintree::WebhookNotification::Kind::LocalPaymentCompleted,
+        "blik_one_click_id",
+      )
+
+      notification = Braintree::WebhookNotification.parse(sample_notification[:bt_signature], sample_notification[:bt_payload])
+      expect(notification.kind).to eq(Braintree::WebhookNotification::Kind::LocalPaymentCompleted)
+
+      local_payment_completed = notification.local_payment_completed
+      expect(local_payment_completed.blik_aliases).to match_array([{:key => "alias-key-1", :label => "alias-label-1"}])
+      expect(local_payment_completed.payer_id).to eq("ABCPAYER")
+      expect(local_payment_completed.payment_id).to eq("PAY-XYZ123")
+      expect(local_payment_completed.payment_method_nonce).to eq("ee257d98-de40-47e8-96b3-a6954ea7a9a4")
+      expect(local_payment_completed.transaction.id).to eq("blik_one_click_id")
+      expect(local_payment_completed.transaction.status).to eq(Braintree::Transaction::Status::Authorized)
+      expect(local_payment_completed.transaction.amount).to eq(49.99)
+      expect(local_payment_completed.transaction.order_id).to eq("order4567")
+    end
   end
 
   context "local_payment_expired" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: braintree
 version: !ruby/object:Gem::Version
-  version: 4.22.0
+  version: 4.23.0
 platform: ruby
 authors:
 - Braintree
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-09-20 00:00:00.000000000 Z
+date: 2024-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -111,6 +111,7 @@ files:
 - lib/braintree/graphql_client.rb
 - lib/braintree/http.rb
 - lib/braintree/local_payment_completed.rb
+- lib/braintree/local_payment_completed/blik_alias.rb
 - lib/braintree/local_payment_expired.rb
 - lib/braintree/local_payment_funded.rb
 - lib/braintree/local_payment_reversed.rb