braintree 4.34.0 → 4.36.0

data/spec/integration/braintree/local_payment_context_spec.rb

@@ -0,0 +1,168 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::LocalPaymentContextGateway do
+  before(:each) { skip("Pending until test data is fixed.") }
+  let(:gateway) do
+    Braintree::Gateway.new(
+      :environment => :development,
+      :merchant_id => "pwpp_multi_account_merchant",
+      :public_key => "pwpp_multi_account_merchant_public_key",
+      :private_key => "pwpp_multi_account_merchant_private_key",
+    )
+  end
+
+  describe "create" do
+    it "can create MBWAY payment context" do
+      input = Braintree::CreateLocalPaymentContextInput.new(
+        amount: {
+          value: "10.00",
+          currency_code: "EUR"
+        },
+        type: Braintree::LocalPaymentType::MBWAY,
+        payer_info: {
+          given_name: "John",
+          surname: "Doe",
+          phone_number: "912345678",
+          phone_country_code: "351"
+        },
+        shipping_address: {
+          street_address: "123 Main St",
+          extended_address: "Apt 4B",
+          locality: "Lisbon",
+          region: "Lisboa",
+          postal_code: "1000-001",
+          country_code: "PT"
+        },
+        return_url: "https://example.com/return",
+        cancel_url: "https://example.com/cancel",
+        merchant_account_id: "eur_pwpp_multi_account_merchant_account",
+      )
+
+      result = gateway.local_payment_context.create(input)
+
+      expect(result.success?).to eq(true)
+      expect(result.payment_context).not_to be_nil
+      expect(result.payment_context.id).not_to be_nil
+      expect(result.payment_context.legacy_id).not_to be_nil
+      expect(result.payment_context.type).to eq("MBWAY")
+      expect(result.payment_context.amount.value).to eq("10.00")
+      expect(result.payment_context.amount.currency_code).to eq("EUR")
+    end
+
+    it "can create CRYPTO payment context" do
+      input = Braintree::CreateLocalPaymentContextInput.new(
+        amount: {
+          value: "25.00",
+          currency_code: "USD"
+        },
+        type: Braintree::LocalPaymentType::CRYPTO,
+        payer_info: {
+          given_name: "John",
+          surname: "Doe",
+          email: "john.doe@example.com"
+        },
+        return_url: "https://example.com/return",
+        cancel_url: "https://example.com/cancel",
+        merchant_account_id: "usd_pwpp_multi_account_merchant_account",
+      )
+
+      result = gateway.local_payment_context.create(input)
+
+      expect(result.success?).to eq(true)
+      expect(result.payment_context).not_to be_nil
+      expect(result.payment_context.id).not_to be_nil
+      expect(result.payment_context.legacy_id).not_to be_nil
+      expect(result.payment_context.type).to eq("CRYPTO")
+      expect(result.payment_context.amount.value).to eq("25.00")
+      expect(result.payment_context.amount.currency_code).to eq("USD")
+    end
+
+    it "can create payment context with only required fields" do
+      input = Braintree::CreateLocalPaymentContextInput.new(
+        amount: {
+          value: "15.00",
+          currency_code: "USD"
+        },
+        type: Braintree::LocalPaymentType::CRYPTO,
+        payer_info: {
+          given_name: "Jane",
+          surname: "Smith"
+        },
+        return_url: "https://example.com/return",
+        cancel_url: "https://example.com/cancel",
+      )
+
+      result = gateway.local_payment_context.create(input)
+
+      expect(result.success?).to eq(true)
+      expect(result.payment_context).not_to be_nil
+      expect(result.payment_context.id).not_to be_nil
+      expect(result.payment_context.legacy_id).not_to be_nil
+      expect(result.payment_context.type).to eq("CRYPTO")
+      expect(result.payment_context.amount.value).to eq("15.00")
+      expect(result.payment_context.amount.currency_code).to eq("USD")
+    end
+
+    it "returns error for invalid input" do
+      input = Braintree::CreateLocalPaymentContextInput.new(
+        amount: {
+          value: "invalid",
+          currency_code: "EUR"
+        },
+        type: Braintree::LocalPaymentType::MBWAY,
+        payer_info: {
+          given_name: "John",
+          surname: "Doe"
+        },
+        return_url: "https://example.com/return",
+        cancel_url: "https://example.com/cancel",
+        merchant_account_id: "eur_pwpp_multi_account_merchant_account",
+      )
+
+      result = gateway.local_payment_context.create(input)
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.size).to be > 0
+    end
+  end
+
+  describe "find" do
+    it "can find a payment context by ID" do
+      input = Braintree::CreateLocalPaymentContextInput.new(
+        amount: {
+          value: "10.00",
+          currency_code: "EUR"
+        },
+        type: Braintree::LocalPaymentType::MBWAY,
+        payer_info: {
+          given_name: "John",
+          surname: "Doe",
+          phone_number: "912345678",
+          phone_country_code: "351"
+        },
+        return_url: "https://example.com/return",
+        cancel_url: "https://example.com/cancel",
+        merchant_account_id: "eur_pwpp_multi_account_merchant_account",
+      )
+
+      create_result = gateway.local_payment_context.create(input)
+      expect(create_result.success?).to eq(true)
+
+      payment_context_id = create_result.payment_context.id
+      find_result = gateway.local_payment_context.find(payment_context_id)
+
+      expect(find_result.success?).to eq(true)
+      expect(find_result.payment_context).not_to be_nil
+      expect(find_result.payment_context.id).to eq(payment_context_id)
+      expect(find_result.payment_context.legacy_id).not_to be_nil
+      expect(find_result.payment_context.type).to eq("MBWAY")
+    end
+
+    it "raises NotFoundError for non-existent ID" do
+      expect {
+        gateway.local_payment_context.find("non-existent-id-123")
+      }.to raise_error(Braintree::NotFoundError)
+    end
+  end
+end

data/spec/integration/braintree/merchant_spec.rb

@@ -1,186 +1,22 @@
 require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
 
 describe Braintree::MerchantGateway do
+  # NEXT_MAJOR_VERSION remove this test
   describe "create" do
-    xit "creates a merchant" do
+    it "raises a server error because the endpoint has been disabled" do
       gateway = Braintree::Gateway.new(
         :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"),
       )
 
-      result = gateway.merchant.create(
-        :email => "name@email.com",
-        :country_code_alpha3 => "GBR",
-        :payment_methods => ["credit_card", "paypal"],
-      )
-
-      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("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
-      expect(credentials.refresh_token).not_to be_nil
-      expect(credentials.expires_at).not_to be_nil
-      expect(credentials.token_type).to eq("bearer")
-    end
-
-    it "gives an error when using invalid payment_methods" do
-      gateway = Braintree::Gateway.new(
-        :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"),
-      )
-
-      result = gateway.merchant.create(
-        :email => "name@email.com",
-        :country_code_alpha3 => "GBR",
-        :payment_methods => ["fake_money"],
-      )
-
-      expect(result).not_to be_success
-      errors = result.errors.for(:merchant).on(:payment_methods)
-
-      expect(errors[0].code).to eq(Braintree::ErrorCodes::Merchant::PaymentMethodsAreInvalid)
-    end
-
-    context "credentials" do
-      around(:each) do |example|
-        old_merchant_id_value = Braintree::Configuration.merchant_id
-        example.run
-        Braintree::Configuration.merchant_id = old_merchant_id_value
-      end
-
-      xit "allows using a merchant_id passed in through Gateway" do
-        Braintree::Configuration.merchant_id = nil
-
-        gateway = Braintree::Gateway.new(
-          :client_id => "client_id$#{Braintree::Configuration.environment}$integration_client_id",
-          :client_secret => "client_secret$#{Braintree::Configuration.environment}$integration_client_secret",
-          :merchant_id => "integration_merchant_id",
-          :logger => Logger.new("/dev/null"),
-        )
-        result = gateway.merchant.create(
+      expect do
+        gateway.merchant.create(
           :email => "name@email.com",
           :country_code_alpha3 => "GBR",
           :payment_methods => ["credit_card", "paypal"],
         )
-
-        expect(result).to be_success
-      end
-    end
-
-    context "multiple currencies" do
-      before(:each) do
-        @gateway = Braintree::Gateway.new(
-          :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
-
-      xit "creates an EU multi currency merchant for paypal and credit_card" do
-        result = @gateway.merchant.create(
-          :email => "name@email.com",
-          :country_code_alpha3 => "GBR",
-          :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("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
-        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 == "GBP" }
-        expect(merchant_account.default).to eq(true)
-        expect(merchant_account.currency_iso_code).to eq("GBP")
-
-        merchant_account = merchant_accounts.detect { |ma| ma.id == "USD" }
-        expect(merchant_account.default).to eq(false)
-        expect(merchant_account.currency_iso_code).to eq("USD")
-      end
-
-
-      xit "creates a paypal-only merchant that accepts multiple currencies" do
-        result = @gateway.merchant.create(
-          :email => "name@email.com",
-          :country_code_alpha3 => "GBR",
-          :payment_methods => ["paypal"],
-          :currencies => ["GBP", "USD"],
-          :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("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
-        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(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(true)
-        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 => "GBR",
-          :payment_methods => ["paypal"],
-          :currencies => ["FAKE", "GBP"],
-          :paypal_account => {
-            :client_id => "paypal_client_id",
-            :client_secret => "paypal_client_secret",
-          },
-        )
-
-        expect(result).not_to be_success
-        errors = result.errors.for(:merchant).on(:currencies)
-
-        expect(errors[0].code).to eq(Braintree::ErrorCodes::Merchant::CurrenciesAreInvalid)
-      end
+      end.to raise_error(Braintree::ServerError)
     end
   end
 

data/spec/integration/braintree/payment_method_spec.rb

@@ -813,7 +813,7 @@ describe Braintree::PaymentMethod do
         expect(update_result.payment_method.verification.credit_card[:account_type]).to eq("credit")
       end
 
-      it "updates the credit card with account_type debit" do
+      xit "updates the credit card with account_type debit" do
         customer = Braintree::Customer.create!
         credit_card = Braintree::CreditCard.create!(
           :cardholder_name => "Original Holder",
@@ -1020,6 +1020,179 @@ describe Braintree::PaymentMethod do
       end
     end
 
+    it "does card verification for ApplePay" do
+      customer = Braintree::Customer.create!
+      result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
+        :customer_id => customer.id,
+        :options => {
+          :verify_card => true,
+          :verification_amount => "1.00",
+          :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+        },
+      )
+      expect(result).to be_success
+      verification = result.payment_method.verification
+
+      expect(verification.merchant_account_id).to eq(SpecHelper::NonDefaultMerchantAccountId)
+      expect(verification.amount).to eq(BigDecimal("1.00"))
+    end
+
+    it "verifies the apple pay card when only verify_card set to true is provided" do
+      customer = Braintree::Customer.create!
+
+      result = Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
+        :options => {
+          :verify_card => true,
+        },
+      )
+
+      expect(result).to be_success
+      expect(result.payment_method).to be_a(Braintree::ApplePayCard)
+      verification = result.payment_method.verification
+      expect(verification).not_to be_nil
+    end
+
+    it "does not verify the apple pay card when verify_card is false" do
+      customer = Braintree::Customer.create!
+
+      result = Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
+        :options => {
+          :verify_card => false,
+          :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+          :verification_amount => "10.00",
+        },
+      )
+
+      expect(result).to be_success
+      expect(result.payment_method).to be_a(Braintree::ApplePayCard)
+
+      verification = result.payment_method.verification
+      expect(verification).to be_nil
+    end
+
+    it "errors when verification amount is negative for apple pay" do
+      customer = Braintree::Customer.create!
+      result = Braintree::PaymentMethod.create(
+        payment_method_nonce: Braintree::Test::Nonce::ApplePayVisa,
+        :customer_id => customer.id,
+        options: {
+          verify_card: true,
+          verification_amount: "-1.00",
+        },
+      )
+
+      expect(result).not_to be_success
+      expect(result.errors.for(:apple_pay).for(:options).on(:verification_amount)[0].code).to eq Braintree::ErrorCodes::ApplePay::Options::VerificationAmountCannotBeNegative
+    end
+
+    it "errors when verification amount format is invalid for apple pay" do
+      customer = Braintree::Customer.create!
+
+      result = Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
+        :options => {
+          :verify_card => true,
+          :verification_amount => "0.001",
+          :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+        },
+      )
+
+      expect(result).to_not be_success
+      expect(result.errors.for(:apple_pay).for(:options).on(:verification_amount)[0].code).to eq Braintree::ErrorCodes::ApplePay::Options::VerificationAmountFormatIsInvalid
+    end
+
+    it "errors when verification amount is not supported for processor on apple pay" do
+      customer = Braintree::Customer.create!
+
+      result = Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
+        :options => {
+          :verify_card => true,
+          :verification_amount => "0.01",
+          :verification_merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
+        },
+      )
+
+      expect(result).to_not be_success
+      expect(result.errors.for(:apple_pay).for(:options).on(:verification_amount)[0].code).to eq Braintree::ErrorCodes::ApplePay::Options::VerificationAmountNotSupportedByProcessor
+    end
+
+    it "errors when verification amount is too large on apple pay" do
+      customer = Braintree::Customer.create!
+
+      result = Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
+        :options => {
+          :verify_card => true,
+          :verification_amount => ((2**31) / 100.0).to_s,
+          :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+        },
+      )
+
+      expect(result).to_not be_success
+      expect(result.errors.for(:apple_pay).for(:options).on(:verification_amount)[0].code).to eq Braintree::ErrorCodes::ApplePay::Options::VerificationAmountIsTooLarge
+    end
+
+    it "errors when verification merchant account is invalid" do
+      customer = Braintree::Customer.create!
+
+      result = Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
+        :options => {
+          :verify_card => true,
+          :verification_amount => "10.00",
+          :verification_merchant_account_id => "BAD_MERCHANT_ACCOUNT",
+        },
+      )
+
+      expect(result).to_not be_success
+      expect(result.errors.for(:apple_pay).for(:options).on(:verification_merchant_account_id)[0].code).to eq Braintree::ErrorCodes::ApplePay::Options::VerificationMerchantAccountIdIsInvalid
+    end
+
+    it "errors when verification merchant account is suspended" do
+      customer = Braintree::Customer.create!
+
+      result = Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
+        :options => {
+          :verify_card => true,
+          :verification_amount => "10.00",
+          :verification_merchant_account_id => SpecHelper::SuspendedAccount,
+        },
+      )
+
+      expect(result).to_not be_success
+      expect(result.errors.for(:apple_pay).for(:options).on(:verification_merchant_account_id)[1].code).to eq Braintree::ErrorCodes::ApplePay::Options::VerificationMerchantAccountIsSuspended
+    end
+
+    it "errors when account_type not supported by merchant on apple_pay" do
+      customer = Braintree::Customer.create!
+
+      result = Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
+        :options => {
+          :verify_card => true,
+          :verification_amount => "10.00",
+          :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+          :verification_account_type => "credit",
+        },
+      )
+
+      expect(result).to_not be_success
+      expect(result.errors.for(:apple_pay).for(:options).on(:verification_account_type)[0].code).to eq Braintree::ErrorCodes::ApplePay::Options::VerificationAccountTypeNotSupported
+    end
+
     context "verification_currency_iso_code" do
       it "validates verification_currency_iso_code against currency configured in default merchant account" do
         nonce = nonce_for_new_payment_method(

data/spec/integration/braintree/payment_method_us_bank_account_spec.rb

@@ -96,7 +96,7 @@ describe Braintree::PaymentMethod do
           expect(us_bank_account.routing_number).to eq("123456789")
           expect(us_bank_account.last_4).to eq("0000")
           expect(us_bank_account.account_type).to eq("checking")
-          expect(us_bank_account.account_holder_name).to eq("Dan Schulman")
+          expect(us_bank_account.account_holder_name).to eq("Marty McFly")
           expect(us_bank_account.bank_name).to match(/Wells Fargo/)
           expect(us_bank_account.default).to eq(true)
           expect(us_bank_account.ach_mandate.accepted_at).to be_a Time

data/spec/integration/braintree/test_transaction_spec.rb

@@ -6,7 +6,7 @@ describe Braintree::TestTransaction do
     it "changes transaction status to settled" do
       sale_result = Braintree::Transaction.sale(
         :amount => "100",
-        :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutVisa,
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
         :options => {
         :submit_for_settlement => true
       },
@@ -22,7 +22,7 @@ describe Braintree::TestTransaction do
     it "changes transaction status to settlement_confirmed" do
       sale_result = Braintree::Transaction.sale(
         :amount => "100",
-        :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutVisa,
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
         :options => {
           :submit_for_settlement => true
         },
@@ -38,7 +38,7 @@ describe Braintree::TestTransaction do
     it "changes transaction status to settlement_declined" do
       sale_result = Braintree::Transaction.sale(
         :amount => "100",
-        :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutVisa,
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
         :options => {
           :submit_for_settlement => true
         },
@@ -54,7 +54,7 @@ describe Braintree::TestTransaction do
     it "changes transaction status to settlement_pending" do
       sale_result = Braintree::Transaction.sale(
         :amount => "100",
-        :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutVisa,
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
         :options => {
           :submit_for_settlement => true
         },
@@ -70,7 +70,7 @@ describe Braintree::TestTransaction do
     it "returns a validation error when invalid transition is specified" do
       sale_result = Braintree::Transaction.sale(
         :amount => "100",
-        :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutVisa,
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
       )
       expect(sale_result.success?).to eq(true)
 
@@ -110,7 +110,7 @@ describe Braintree::TestTransaction do
 
           sale_result = transaction_gateway.sale(
             :amount => "100",
-            :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutVisa,
+            :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
           )
           testing_gateway.settle(sale_result.transaction.id)
         end