braintree 4.21.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

@@ -48,6 +48,25 @@ describe Braintree::CreditCardVerification, "search" do
       expect(result.credit_card_verification.processor_response_type).to eq(Braintree::ProcessorResponseTypes::Approved)
     end
 
+    it "creates a new verification for Visa ANI" do
+      verification_params = {
+        :credit_card => {
+          :expiration_date => "05/2012",
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+        },
+      }
+
+      result = Braintree::CreditCardVerification.create(verification_params)
+
+      expect(result).to be_success
+      expect(result.credit_card_verification.status).to eq(Braintree::CreditCardVerification::Status::Verified)
+      expect(result.credit_card_verification.processor_response_code).to eq("1000")
+      expect(result.credit_card_verification.processor_response_text).to eq("Approved")
+      expect(result.credit_card_verification.ani_first_name_response_code).to eq("I")
+      expect(result.credit_card_verification.ani_last_name_response_code).to eq("I")
+      expect(result.credit_card_verification.processor_response_type).to eq(Braintree::ProcessorResponseTypes::Approved)
+    end
+
     it "creates a new verification from external vault param" do
       verification_params = {
         :credit_card => {
@@ -138,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/merchant_account_spec.rb

@@ -97,7 +97,7 @@ describe Braintree::MerchantAccount do
 
       result = gateway.merchant.create(
         :email => "name@email.com",
-        :country_code_alpha3 => "USA",
+        :country_code_alpha3 => "GBR",
         :payment_methods => ["credit_card", "paypal"],
       )
 
@@ -109,7 +109,7 @@ describe Braintree::MerchantAccount do
       result = gateway.merchant_account.all
       expect(result).to be_success
       expect(result.merchant_accounts.count).to eq(1)
-      expect(result.merchant_accounts.first.currency_iso_code).to eq("USD")
+      expect(result.merchant_accounts.first.currency_iso_code).to eq("GBP")
       expect(result.merchant_accounts.first.status).to eq("active")
       expect(result.merchant_accounts.first.default).to eq(true)
     end

data/spec/integration/braintree/merchant_spec.rb

@@ -11,7 +11,7 @@ describe Braintree::MerchantGateway do
 
       result = gateway.merchant.create(
         :email => "name@email.com",
-        :country_code_alpha3 => "USA",
+        :country_code_alpha3 => "GBR",
         :payment_methods => ["credit_card", "paypal"],
       )
 
@@ -21,10 +21,10 @@ describe Braintree::MerchantGateway do
       expect(merchant.id).not_to be_nil
       expect(merchant.email).to eq("name@email.com")
       expect(merchant.company_name).to eq("name@email.com")
-      expect(merchant.country_code_alpha3).to eq("USA")
-      expect(merchant.country_code_alpha2).to eq("US")
-      expect(merchant.country_code_numeric).to eq("840")
-      expect(merchant.country_name).to eq("United States of America")
+      expect(merchant.country_code_alpha3).to eq("GBR")
+      expect(merchant.country_code_alpha2).to eq("GB")
+      expect(merchant.country_code_numeric).to eq("826")
+      expect(merchant.country_name).to eq("United Kingdom")
 
       credentials = result.credentials
       expect(credentials.access_token).not_to be_nil
@@ -42,7 +42,7 @@ describe Braintree::MerchantGateway do
 
       result = gateway.merchant.create(
         :email => "name@email.com",
-        :country_code_alpha3 => "USA",
+        :country_code_alpha3 => "GBR",
         :payment_methods => ["fake_money"],
       )
 
@@ -70,7 +70,7 @@ describe Braintree::MerchantGateway do
         )
         result = gateway.merchant.create(
           :email => "name@email.com",
-          :country_code_alpha3 => "USA",
+          :country_code_alpha3 => "GBR",
           :payment_methods => ["credit_card", "paypal"],
         )
 
@@ -81,47 +81,12 @@ describe Braintree::MerchantGateway do
     context "multiple currencies" do
       before(:each) do
         @gateway = Braintree::Gateway.new(
-          :client_id => "client_id$development$signup_client_id",
-          :client_secret => "client_secret$development$signup_client_secret",
+          :client_id => "client_id$#{Braintree::Configuration.environment}$integration_client_id",
+          :client_secret => "client_secret$#{Braintree::Configuration.environment}$integration_client_secret",
           :logger => Logger.new("/dev/null"),
         )
       end
 
-      it "creates a US multi currency merchant for paypal and credit_card" do
-        result = @gateway.merchant.create(
-          :email => "name@email.com",
-          :country_code_alpha3 => "USA",
-          :payment_methods => ["credit_card", "paypal"],
-          :currencies => ["GBP", "USD"],
-        )
-
-        merchant = result.merchant
-        expect(merchant.id).not_to be_nil
-        expect(merchant.email).to eq("name@email.com")
-        expect(merchant.company_name).to eq("name@email.com")
-        expect(merchant.country_code_alpha3).to eq("USA")
-        expect(merchant.country_code_alpha2).to eq("US")
-        expect(merchant.country_code_numeric).to eq("840")
-        expect(merchant.country_name).to eq("United States of America")
-
-        credentials = result.credentials
-        expect(credentials.access_token).not_to be_nil
-        expect(credentials.refresh_token).not_to be_nil
-        expect(credentials.expires_at).not_to be_nil
-        expect(credentials.token_type).to eq("bearer")
-
-        merchant_accounts = merchant.merchant_accounts
-        expect(merchant_accounts.count).to eq(2)
-
-        merchant_account = merchant_accounts.detect { |ma| ma.id == "USD" }
-        expect(merchant_account.default).to eq(true)
-        expect(merchant_account.currency_iso_code).to eq("USD")
-
-        merchant_account = merchant_accounts.detect { |ma| ma.id == "GBP" }
-        expect(merchant_account.default).to eq(false)
-        expect(merchant_account.currency_iso_code).to eq("GBP")
-      end
-
       it "creates an EU multi currency merchant for paypal and credit_card" do
         result = @gateway.merchant.create(
           :email => "name@email.com",
@@ -161,7 +126,7 @@ describe Braintree::MerchantGateway do
       it "creates a paypal-only merchant that accepts multiple currencies" do
         result = @gateway.merchant.create(
           :email => "name@email.com",
-          :country_code_alpha3 => "USA",
+          :country_code_alpha3 => "GBR",
           :payment_methods => ["paypal"],
           :currencies => ["GBP", "USD"],
           :paypal_account => {
@@ -176,10 +141,10 @@ describe Braintree::MerchantGateway do
         expect(merchant.id).not_to be_nil
         expect(merchant.email).to eq("name@email.com")
         expect(merchant.company_name).to eq("name@email.com")
-        expect(merchant.country_code_alpha3).to eq("USA")
-        expect(merchant.country_code_alpha2).to eq("US")
-        expect(merchant.country_code_numeric).to eq("840")
-        expect(merchant.country_name).to eq("United States of America")
+        expect(merchant.country_code_alpha3).to eq("GBR")
+        expect(merchant.country_code_alpha2).to eq("GB")
+        expect(merchant.country_code_numeric).to eq("826")
+        expect(merchant.country_name).to eq("United Kingdom")
 
         credentials = result.credentials
         expect(credentials.access_token).not_to be_nil
@@ -191,90 +156,18 @@ describe Braintree::MerchantGateway do
         expect(merchant_accounts.count).to eq(2)
 
         merchant_account = merchant_accounts.detect { |ma| ma.id == "USD" }
-        expect(merchant_account.default).to eq(true)
+        expect(merchant_account.default).to eq(false)
         expect(merchant_account.currency_iso_code).to eq("USD")
 
         merchant_account = merchant_accounts.detect { |ma| ma.id == "GBP" }
-        expect(merchant_account.default).to eq(false)
-        expect(merchant_account.currency_iso_code).to eq("GBP")
-      end
-
-      it "allows creation of non-US merchant if onboarding application is internal" do
-        result = @gateway.merchant.create(
-          :email => "name@email.com",
-          :country_code_alpha3 => "JPN",
-          :payment_methods => ["paypal"],
-          :paypal_account => {
-            :client_id => "paypal_client_id",
-            :client_secret => "paypal_client_secret",
-          },
-        )
-
-        expect(result).to be_success
-
-        merchant = result.merchant
-        expect(merchant.id).not_to be_nil
-        expect(merchant.email).to eq("name@email.com")
-        expect(merchant.company_name).to eq("name@email.com")
-        expect(merchant.country_code_alpha3).to eq("JPN")
-        expect(merchant.country_code_alpha2).to eq("JP")
-        expect(merchant.country_code_numeric).to eq("392")
-        expect(merchant.country_name).to eq("Japan")
-
-        credentials = result.credentials
-        expect(credentials.access_token).not_to be_nil
-        expect(credentials.refresh_token).not_to be_nil
-        expect(credentials.expires_at).not_to be_nil
-        expect(credentials.token_type).to eq("bearer")
-
-        merchant_accounts = merchant.merchant_accounts
-        expect(merchant_accounts.count).to eq(1)
-
-        merchant_account = merchant_accounts.detect { |ma| ma.id == "JPY" }
         expect(merchant_account.default).to eq(true)
-        expect(merchant_account.currency_iso_code).to eq("JPY")
-      end
-
-      it "defaults to USD for non-US merchant if onboarding application is internal and country currency not supported" do
-        result = @gateway.merchant.create(
-          :email => "name@email.com",
-          :country_code_alpha3 => "YEM",
-          :payment_methods => ["paypal"],
-          :paypal_account => {
-            :client_id => "paypal_client_id",
-            :client_secret => "paypal_client_secret",
-          },
-        )
-
-        expect(result).to be_success
-
-        merchant = result.merchant
-        expect(merchant.id).not_to be_nil
-        expect(merchant.email).to eq("name@email.com")
-        expect(merchant.company_name).to eq("name@email.com")
-        expect(merchant.country_code_alpha3).to eq("YEM")
-        expect(merchant.country_code_alpha2).to eq("YE")
-        expect(merchant.country_code_numeric).to eq("887")
-        expect(merchant.country_name).to eq("Yemen")
-
-        credentials = result.credentials
-        expect(credentials.access_token).not_to be_nil
-        expect(credentials.refresh_token).not_to be_nil
-        expect(credentials.expires_at).not_to be_nil
-        expect(credentials.token_type).to eq("bearer")
-
-        merchant_accounts = merchant.merchant_accounts
-        expect(merchant_accounts.count).to eq(1)
-
-        merchant_account = merchant_accounts.detect { |ma| ma.id == "USD" }
-        expect(merchant_account.default).to eq(true)
-        expect(merchant_account.currency_iso_code).to eq("USD")
+        expect(merchant_account.currency_iso_code).to eq("GBP")
       end
 
       it "returns error if invalid currency is passed" do
         result = @gateway.merchant.create(
           :email => "name@email.com",
-          :country_code_alpha3 => "USA",
+          :country_code_alpha3 => "GBR",
           :payment_methods => ["paypal"],
           :currencies => ["FAKE", "GBP"],
           :paypal_account => {
@@ -317,20 +210,6 @@ describe Braintree::MerchantGateway do
       end
     end
 
-    context "merchant has no processor connection supporting apple pay" do
-      before do
-        Braintree::Configuration.merchant_id = "forward_payment_method_merchant_id"
-        Braintree::Configuration.public_key = "forward_payment_method_public_key"
-        Braintree::Configuration.private_key = "forward_payment_method_private_key"
-      end
-
-      it "returns a validation error" do
-        result = Braintree::Merchant.provision_raw_apple_pay
-        expect(result).not_to be_success
-        expect(result.errors.for(:apple_pay).first.code).to eq(Braintree::ErrorCodes::ApplePay::ApplePayCardsAreNotAccepted)
-      end
-    end
-
     def _save_config
       @original_config = {
         :merchant_id => Braintree::Configuration.merchant_id,