braintree 4.23.0 → 4.34.0

data/spec/integration/braintree/transaction_transfer_type_spec.rb

@@ -0,0 +1,325 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::Transaction do
+  describe "self.transfer type" do
+    it "should create a transaction with valid transfer types and merchant account id" do
+      transaction_params = {
+        :type => "sale",
+        :amount => "100.00",
+        :merchant_account_id => "aft_first_data_wallet_transfer",
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "06/2026",
+          :cvv => "123"
+        },
+        :transfer => {
+          :type => "wallet_transfer",
+          :receiver => {
+            :first_name => "John",
+            :last_name => "Smith",
+            :middle_name => "D",
+            :address => {
+              :country_code_alpha2 => "US",
+              :locality => "LA",
+              :region => "CA",
+              :street_address => "1st Main"
+            }
+          },
+          :sender => {
+            :account_reference_number => "123456789",
+            :date_of_birth => Date.new(2002, 1, 2),
+            :first_name => "Lisa",
+            :last_name => "Ray",
+            :middle_name => "D",
+            :address => {
+              :country_code_alpha2 => "US",
+              :locality => "LA",
+              :region => "CA",
+              :street_address => "12th Main"
+            }
+          },
+        }
+      }
+
+      result = Braintree::Transaction.sale(transaction_params)
+      expect(result.success?).to eq(true)
+      expect(result.transaction.account_funding_transaction).to eq(true)
+      expect(result.transaction.status).to eq(Braintree::Transaction::Status::Authorized)
+    end
+
+    it "should fail on transaction with non brazil merchant" do
+      transaction_params = {
+        :type => "sale",
+        :amount => "100.00",
+        :merchant_account_id => "aft_first_data_wallet_transfer",
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "06/2026",
+          :cvv => "123"
+        },
+        :transfer => {
+          :type => "invalid_transfer",
+        },
+      }
+
+      result =  Braintree::Transaction.sale(transaction_params)
+      expect(result.success?).to eq(false)
+    end
+
+    it "should create a transaction with valid transfer types and merchant account id" do
+      SpecHelper::SdwoSupportedTransferTypes.each do |transfer_type|
+        transaction_params = {
+          :type => "sale",
+          :amount => "100.00",
+          :merchant_account_id => "card_processor_brl_sdwo",
+          :credit_card => {
+            :number => "4111111111111111",
+            :expiration_date => "06/2026",
+            :cvv => "123"
+          },
+          :descriptor => {
+            :name => "companynme12*product1",
+            :phone => "1232344444",
+            :url => "example.com",
+          },
+          :billing => {
+            :first_name => "Bob James",
+            :country_code_alpha2 => "CA",
+            :extended_address => "",
+            :locality => "Trois-Rivires",
+            :region => "QC",
+            :postal_code => "G8Y 156",
+            :street_address => "2346 Boul Lane",
+          },
+          :transfer => {
+            :type => transfer_type,
+            :sender => {
+              :first_name => "Alice",
+              :last_name => "Silva",
+              :account_reference_number => "1000012345",
+              :tax_id => "12345678900",
+              :address => {
+                :street_address => "Rua das Flores, 100",
+                :extended_address => "2B",
+                :locality => "São Paulo",
+                :region => "SP",
+                :postal_code => "01001-000",
+                :country_code_alpha2 => "BR",
+                :international_phone => {
+                  :country_code => "55",
+                  :national_number => "1234567890"
+                }
+              }
+            },
+            :receiver => {
+              :first_name => "Bob",
+              :last_name => "Souza",
+              :account_reference_number => "2000012345",
+              :tax_id => "98765432100",
+              :address => {
+                :street_address => "Avenida Brasil, 200",
+                :extended_address => "2B",
+                :locality => "Rio de Janeiro",
+                :region => "RJ",
+                :postal_code => "20040-002",
+                :country_code_alpha2 => "BR",
+                :international_phone => {
+                  :country_code => "55",
+                  :national_number => "9876543210"
+                }
+              }
+            }
+          },
+          :options => {
+            :store_in_vault_on_success => true,
+          }
+        }
+
+        result = Braintree::Transaction.sale(transaction_params)
+        expect(result.success?).to eq(true)
+        expect(result.transaction.status).to eq(Braintree::Transaction::Status::Authorized)
+      end
+    end
+
+    it "should fail when transfer details are not provided" do
+      transaction_params = {
+        :type => "sale",
+        :amount => "100.00",
+        :merchant_account_id => "card_processor_brl_sdwo",
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "06/2026",
+          :cvv => "123"
+        },
+        :descriptor => {
+          :name => "companynme12*product1",
+          :phone => "1232344444",
+          :url => "example.com",
+        },
+        :billing => {
+          :first_name => "Bob James",
+          :country_code_alpha2 => "CA",
+          :extended_address => "",
+          :locality => "Trois-Rivires",
+          :region => "QC",
+          :postal_code => "G8Y 156",
+          :street_address => "2346 Boul Lane",
+        },
+        :options => {
+          :store_in_vault_on_success => true,
+        }
+      }
+
+      result = Braintree::Transaction.sale(transaction_params)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:transaction).first.code).to eq(Braintree::ErrorCodes::Transaction::TransactionTransferDetailsAreMandatory)
+    end
+
+    it "should fail on transaction with invalid transfer type" do
+      transaction_params = {
+        :type => "sale",
+        :amount => "100.00",
+        :merchant_account_id => "card_processor_brl_sdwo",
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "06/2026",
+          :cvv => "123"
+        },
+        :descriptor => {
+          :name => "companynme12*product1",
+          :phone => "1232344444",
+          :url => "example.com",
+        },
+        :billing => {
+          :first_name => "Bob James",
+          :country_code_alpha2 => "CA",
+          :extended_address => "",
+          :locality => "Trois-Rivires",
+          :region => "QC",
+          :postal_code => "G8Y 156",
+          :street_address => "2346 Boul Lane",
+        },
+        :transfer => {
+          :type => "invalid_transfer_type",
+          :sender => {
+            :first_name => "Alice",
+            :last_name => "Silva",
+            :account_reference_number => "1000012345",
+            :tax_id => "12345678900",
+            :address => {
+              :street_address => "Rua das Flores, 100",
+              :extended_address => "2B",
+              :locality => "São Paulo",
+              :region => "SP",
+              :postal_code => "01001-000",
+              :country_code_alpha2 => "BR",
+              :international_phone => {
+                :country_code => "55",
+                :national_number => "1234567890"
+              }
+            }
+          },
+          :receiver => {
+            :first_name => "Bob",
+            :last_name => "Souza",
+            :account_reference_number => "2000012345",
+            :tax_id => "98765432100",
+            :address => {
+              :street_address => "Avenida Brasil, 200",
+              :extended_address => "2B",
+              :locality => "Rio de Janeiro",
+              :region => "RJ",
+              :postal_code => "20040-002",
+              :country_code_alpha2 => "BR",
+              :international_phone => {
+                :country_code => "55",
+                :national_number => "9876543210"
+              }
+            }
+          }
+        },
+        :options => {
+          :store_in_vault_on_success => true,
+        }
+      }
+
+      result =  Braintree::Transaction.sale(transaction_params)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:account_funding_transaction).first.code).to eq(Braintree::ErrorCodes::Transaction::TransactionTransferTypeIsInvalid)
+    end
+
+    it "should create a transaction when transfer type is nil" do
+      transaction_params = {
+        :type => "sale",
+        :amount => "100.00",
+        :merchant_account_id => "card_processor_brl_sdwo",
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "06/2026",
+          :cvv => "123"
+        },
+        :descriptor => {
+          :name => "companynme12*product1",
+          :phone => "1232344444",
+          :url => "example.com",
+        },
+        :billing => {
+          :first_name => "Bob James",
+          :country_code_alpha2 => "CA",
+          :extended_address => "",
+          :locality => "Trois-Rivires",
+          :region => "QC",
+          :postal_code => "G8Y 156",
+          :street_address => "2346 Boul Lane",
+        },
+        :transfer => {
+          :type => nil,
+          :sender => {
+            :first_name => "Alice",
+            :last_name => "Silva",
+            :account_reference_number => "1000012345",
+            :tax_id => "12345678900",
+            :address => {
+              :street_address => "Rua das Flores, 100",
+              :extended_address => "2B",
+              :locality => "São Paulo",
+              :region => "SP",
+              :postal_code => "01001-000",
+              :country_code_alpha2 => "BR",
+              :international_phone => {
+                :country_code => "55",
+                :national_number => "1234567890"
+              }
+            }
+          },
+          :receiver => {
+            :first_name => "Bob",
+            :last_name => "Souza",
+            :account_reference_number => "2000012345",
+            :tax_id => "98765432100",
+            :address => {
+              :street_address => "Avenida Brasil, 200",
+              :extended_address => "2B",
+              :locality => "Rio de Janeiro",
+              :region => "RJ",
+              :postal_code => "20040-002",
+              :country_code_alpha2 => "BR",
+              :international_phone => {
+                :country_code => "55",
+                :national_number => "9876543210"
+              }
+            }
+          }
+        },
+        :options => {
+          :store_in_vault_on_success => true,
+        }
+      }
+
+      result =  Braintree::Transaction.sale(transaction_params)
+      expect(result.success?).to eq(true)
+      expect(result.transaction.status).to eq(Braintree::Transaction::Status::Authorized)
+    end
+  end
+end

data/spec/integration/braintree/transaction_us_bank_account_spec.rb

@@ -140,7 +140,6 @@ describe Braintree::Transaction do
             expect(transaction.us_bank_account_details.account_type).to eq("checking")
             expect(transaction.us_bank_account_details.account_holder_name).to eq("John Doe")
             expect(transaction.us_bank_account_details.bank_name).to match(/CHASE/)
-            expect(transaction.us_bank_account_details.ach_mandate.text).to eq("cl mandate text")
             expect(transaction.us_bank_account_details.ach_mandate.accepted_at).to be_a Time
           end
 

data/spec/integration/braintree/us_bank_account_spec.rb

@@ -23,7 +23,6 @@ describe Braintree::UsBankAccount do
       expect(us_bank_account.account_type).to eq("checking")
       expect(us_bank_account.account_holder_name).to eq("John Doe")
       expect(us_bank_account.bank_name).to match(/CHASE/)
-      expect(us_bank_account.ach_mandate.text).to eq("cl mandate text")
       expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
     end
 
@@ -63,7 +62,6 @@ describe Braintree::UsBankAccount do
       expect(us_bank_account.account_type).to eq("checking")
       expect(us_bank_account.account_holder_name).to eq("John Doe")
       expect(us_bank_account.bank_name).to match(/CHASE/)
-      expect(us_bank_account.ach_mandate.text).to eq("cl mandate text")
       expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
     end
   end
@@ -96,7 +94,6 @@ describe Braintree::UsBankAccount do
       expect(us_bank_account.account_type).to eq("checking")
       expect(us_bank_account.account_holder_name).to eq("John Doe")
       expect(us_bank_account.bank_name).to match(/CHASE/)
-      expect(us_bank_account.ach_mandate.text).to eq("cl mandate text")
       expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
     end
 

data/spec/integration/braintree/us_bank_account_verification_spec.rb

@@ -50,7 +50,7 @@ describe Braintree::UsBankAccountVerification do
         expect(response).to be_success
         expect(response.us_bank_account_verification.status).to eq(Braintree::UsBankAccountVerification::Status::Verified)
 
-        us_bank_account = Braintree::UsBankAccount.find(response.us_bank_account_verification.us_bank_account[:token])
+        us_bank_account = Braintree::UsBankAccount.find(response.us_bank_account_verification.us_bank_account.token)
 
         expect(us_bank_account.verified).to be_truthy
       end

data/spec/spec_helper.rb

@@ -3,8 +3,8 @@ unless defined?(SPEC_HELPER_LOADED)
   project_root = File.expand_path(File.dirname(__FILE__) + "/..")
   require "rubygems"
   require "bundler/setup"
-  require "libxml"
   require "rspec"
+  require "rspec/retry"
   require "pry"
 
   braintree_lib = "#{project_root}/lib"
@@ -34,13 +34,13 @@ unless defined?(SPEC_HELPER_LOADED)
     AibSwedenMaMerchantAccountId = "aib_swe_ma"
     AnotherUsBankMerchantAccountId = "another_us_bank_merchant_account"
     CardProcessorBRLMerchantAccountId = "card_processor_brl"
+    CardProcessorBRLPayFacMerchantAccountId = "card_processor_brl_payfac"
     DefaultMerchantAccountId = "sandbox_credit_card"
     FakeAmexDirectMerchantAccountId = "fake_amex_direct_usd"
     FakeFirstDataMerchantAccountId = "fake_first_data_merchant_account"
     FakeVenmoAccountMerchantAccountId = "fake_first_data_venmo_account"
     HiperBRLMerchantAccountId = "hiper_brl"
     NonDefaultMerchantAccountId = "sandbox_credit_card_non_default"
-    NonDefaultSubMerchantAccountId = "sandbox_sub_merchant_account"
     PinlessDebitMerchantAccountId = "pinless_debit"
     ThreeDSecureMerchantAccountId = "three_d_secure_merchant_account"
     UsBankMerchantAccountId = "us_bank_merchant_account"
@@ -77,6 +77,13 @@ unless defined?(SPEC_HELPER_LOADED)
       :billing_day_of_month => 5
     }
 
+    SdwoSupportedTransferTypes = [
+      "account_to_account",
+      "boleto_ticket",
+      "person_to_person",
+      "wallet_transfer"
+    ]
+
     AddOnIncrease10 = "increase_10"
     AddOnIncrease20 = "increase_20"
     AddOnIncrease30 = "increase_30"
@@ -113,18 +120,40 @@ unless defined?(SPEC_HELPER_LOADED)
       response[:three_d_secure_verification][:three_d_secure_authentication_id]
     end
 
-    def self.create_merchant(params={})
+    def self.get_merchant(params={})
       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"),
       )
 
-      gateway.merchant.create({
-        :email => "name@email.com",
-        :country_code_alpha3 => "GBR",
-        :payment_methods => ["credit_card", "paypal"],
-      }.merge!(params))
+      code = Braintree::OAuthTestHelper.create_grant(gateway, {
+        :merchant_public_id => "partner_merchant_id",
+        :scope => "read_write"
+      })
+
+      result = gateway.oauth.create_token_from_code(
+        :code => code,
+        :scope => "read_write",
+      )
+
+      merchant_gateway = Braintree::Gateway.new(
+        :access_token => result.credentials.access_token,
+        :logger => Logger.new("/dev/null"),
+      )
+
+      ma_result = merchant_gateway.merchant_account.all
+
+      merchant_obj = OpenStruct.new(
+        :id => "partner_merchant_id",
+        :merchant_accounts => ma_result.merchant_accounts,
+      )
+
+      OpenStruct.new(
+        :success? => true,
+        :credentials => result.credentials,
+        :merchant => merchant_obj,
+      )
     end
 
     def self.stub_time_dot_now(desired_time)
@@ -188,10 +217,10 @@ unless defined?(SPEC_HELPER_LOADED)
       end
 
       def matches?(xml_string)
-        @libxml_parse = Braintree::Xml::Parser.hash_from_xml(xml_string)
-        if @libxml_parse != @expected_hash
-          @results = @libxml_parse
-          @failed_parser = "libxml"
+        @xml_parse = Braintree::Xml::Parser.hash_from_xml(xml_string)
+        if @xml_parse != @expected_hash
+          @results = @xml_parse
+          @failed_parser = "xml"
           false
         else
           true
@@ -228,4 +257,9 @@ RSpec.configure do |config|
   config.mock_with :rspec do |mock|
     mock.syntax = [:should, :expect]
   end
+
+  config.verbose_retry = true
+  config.display_try_failure_messages = true
+  config.default_retry_count = 3
+  config.default_sleep_interval = 1
 end

data/spec/unit/braintree/apple_pay_card_spec.rb

@@ -19,9 +19,12 @@ describe Braintree::ApplePayCard do
         street_address: "123 Sesame Street",
       },
       :bin => "411111",
+      :business => "No",
       :card_type => "Apple Pay - MasterCard",
       :cardholder_name => "John Miller",
       :commercial => "No",
+      :consumer => "No",
+      :corporate => "No",
       :country_of_issuance => "USA",
       :created_at => Time.now,
       :customer_id => "cid1",
@@ -33,13 +36,16 @@ describe Braintree::ApplePayCard do
       :expired => false,
       :healthcare => "No",
       :image_url => nil,
+      :is_device_token => false,
       :issuing_bank => "Big Bad Bank",
       :last_4 => "9876",
       :merchant_token_identifier => "merchant-token-123",
       :payment_instrument_name => nil,
       :payroll => "No",
       :prepaid => "No",
+      :prepaid_reloadable => "No",
       :product_id => "MAC",
+      :purchase => "No",
       :source_card_last4 => "1234",
       :source_description => "blah",
       :subscriptions => [
@@ -88,6 +94,7 @@ describe Braintree::ApplePayCard do
       card = Braintree::ApplePayCard._new(:gateway, attributes)
 
       expect(card.merchant_token_identifier).to_not be_nil
+      expect(card.is_device_token).to_not be_nil
       expect(card.source_card_last4).to_not be_nil
     end
   end

data/spec/unit/braintree/bank_account_instant_verification_gateway_spec.rb

@@ -0,0 +1,98 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::BankAccountInstantVerificationGateway do
+  let(:gateway) { double("gateway") }
+  let(:config) { double("config") }
+  let(:graphql_client) { double("graphql_client") }
+  let(:bank_account_instant_verification_gateway) { Braintree::BankAccountInstantVerificationGateway.new(gateway) }
+
+  before do
+    allow(gateway).to receive(:config).and_return(config)
+    allow(gateway).to receive(:graphql_client).and_return(graphql_client)
+  end
+
+  describe "create_jwt" do
+    let(:request) do
+      Braintree::BankAccountInstantVerificationJwtRequest.new(
+        :business_name => "Test Business",
+        :return_url => "https://example.com/success",
+        :cancel_url => "https://example.com/cancel",
+      )
+    end
+
+    it "returns success result with valid response" do
+      mock_response = {
+        :data => {
+          :createBankAccountInstantVerificationJwt => {
+            :jwt => "test-jwt-token"
+          }
+        }
+      }
+
+      allow(graphql_client).to receive(:query).and_return(mock_response)
+
+      result = bank_account_instant_verification_gateway.create_jwt(request)
+
+      expect(result.success?).to eq(true)
+      expect(result.bank_account_instant_verification_jwt).not_to be_nil
+      expect(result.bank_account_instant_verification_jwt.jwt).to eq("test-jwt-token")
+    end
+
+    it "returns error result with validation errors" do
+      mock_response = {
+        :errors => [
+          {
+            :message => "Validation error",
+            :extensions => {}
+          }
+        ]
+      }
+
+      allow(graphql_client).to receive(:query).and_return(mock_response)
+
+      result = bank_account_instant_verification_gateway.create_jwt(request)
+
+      expect(result.success?).to eq(false)
+      expect(result.errors).not_to be_nil
+    end
+
+    it "calls GraphQL client with correct mutation" do
+      mock_response = {
+        :data => {
+          :createBankAccountInstantVerificationJwt => {
+            :jwt => "test-jwt-token"
+          }
+        }
+      }
+
+      expect(graphql_client).to receive(:query).with(
+        /mutation CreateBankAccountInstantVerificationJwt/,
+        {:input=>{:businessName=>"Test Business", :cancelUrl=>"https://example.com/cancel", :returnUrl=>"https://example.com/success"}},
+      ).and_return(mock_response)
+
+      bank_account_instant_verification_gateway.create_jwt(request)
+    end
+
+    it "works with minimal request" do
+      minimal_request = Braintree::BankAccountInstantVerificationJwtRequest.new(
+        :business_name => "Test Business",
+        :return_url => "https://example.com/success",
+      )
+
+      mock_response = {
+        :data => {
+          :createBankAccountInstantVerificationJwt => {
+            :jwt => "test-jwt-token"
+          }
+        }
+      }
+
+      allow(graphql_client).to receive(:query).and_return(mock_response)
+
+      result = bank_account_instant_verification_gateway.create_jwt(minimal_request)
+
+      expect(result.success?).to eq(true)
+      expect(result.bank_account_instant_verification_jwt.jwt).to eq("test-jwt-token")
+    end
+  end
+end

data/spec/unit/braintree/bank_account_instant_verification_jwt_request_spec.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::BankAccountInstantVerificationJwtRequest do
+  describe "to_graphql_variables" do
+    it "includes all fields when present" do
+      request = Braintree::BankAccountInstantVerificationJwtRequest.new(
+        :business_name => "Test Business",
+        :return_url => "https://example.com/success",
+        :cancel_url => "https://example.com/cancel",
+      )
+
+      variables = request.to_graphql_variables
+
+      expect(variables).not_to be_nil
+      expect(variables).to have_key(:input)
+
+      input = variables[:input]
+
+      expect(input[:businessName]).to eq("Test Business")
+      expect(input[:returnUrl]).to eq("https://example.com/success")
+      expect(input[:cancelUrl]).to eq("https://example.com/cancel")
+    end
+
+    it "only includes non-null fields" do
+      request = Braintree::BankAccountInstantVerificationJwtRequest.new(
+        :business_name => "Test Business",
+        :return_url => "https://example.com/success",
+      )
+
+      variables = request.to_graphql_variables
+
+      input = variables[:input]
+
+      expect(input[:businessName]).to eq("Test Business")
+      expect(input[:returnUrl]).to eq("https://example.com/success")
+      expect(input).not_to have_key(:cancelUrl)
+    end
+
+    it "handles empty request" do
+      request = Braintree::BankAccountInstantVerificationJwtRequest.new
+
+      variables = request.to_graphql_variables
+
+      expect(variables).to eq({:input => {}})
+    end
+  end
+
+describe "attribute accessors" do
+  it "allows setting and getting all attributes and initializes with hash of attributes" do
+    request = Braintree::BankAccountInstantVerificationJwtRequest.new(
+      :business_name => "Test Business",
+      :return_url => "https://example.com/success",
+      :cancel_url => "https://example.com/cancel",
+    )
+
+    expect(request.business_name).to eq("Test Business")
+    expect(request.return_url).to eq("https://example.com/success")
+    expect(request.cancel_url).to eq("https://example.com/cancel")
+
+    new_request = Braintree::BankAccountInstantVerificationJwtRequest.new
+
+    new_request.business_name = "Updated Business"
+    new_request.return_url = "https://example.com/updated"
+    new_request.cancel_url = "https://example.com/updated-cancel"
+
+    expect(new_request.business_name).to eq("Updated Business")
+    expect(new_request.return_url).to eq("https://example.com/updated")
+    expect(new_request.cancel_url).to eq("https://example.com/updated-cancel")
+  end
+end
+end