braintree 4.30.0 → 4.32.0

data/spec/integration/braintree/transaction_search_spec.rb

@@ -176,6 +176,16 @@ describe Braintree::Transaction, "search" do
       expect(collection.first.id).to eq(transaction_id)
     end
 
+    it "searches on reason_codes for 3 items" do
+      reason_code = ["R01", "R02"]
+
+      collection = Braintree::Transaction.search do |search|
+        search.reason_code.in reason_code
+      end
+
+      expect(collection.maximum_size).to eq(3)
+    end
+
     it "searches on reason_code" do
       transaction_id = "ach_txn_ret1"
       reason_code = "R01"
@@ -184,9 +194,24 @@ describe Braintree::Transaction, "search" do
         search.reason_code.in reason_code
       end
       item = collection.find { |t| t.id == transaction_id }
+      expect(item.ach_return_code).to eq("R01")
       expect(item.ach_return_responses.first[:reason_code]).to eq("R01")
     end
 
+    it "searches on rejections reason_code" do
+      transaction_id = "ach_txn_ret3"
+      reason_code = "RJCT"
+
+      collection = Braintree::Transaction.search do |search|
+        search.reason_code.in reason_code
+      end
+      item = collection.find { |t| t.id == transaction_id }
+      expect(item.ach_return_code).to eq("RJCT")
+      expect(item.ach_reject_reason).to eq("Bank accounts located outside of the U.S. are not supported.")
+      expect(item.ach_return_responses.first[:reason_code]).to eq("RJCT")
+      expect(item.ach_return_responses.first[:reject_reason]).to eq("Bank accounts located outside of the U.S. are not supported.")
+    end
+
     it "searches on reason_codes" do
       reason_code = "any_reason_code"
 
@@ -194,7 +219,7 @@ describe Braintree::Transaction, "search" do
         search.reason_code.is reason_code
       end
 
-      expect(collection.maximum_size).to eq(4)
+      expect(collection.maximum_size).to eq(6)
     end
 
     context "multiple value fields" do
@@ -588,29 +613,6 @@ describe Braintree::Transaction, "search" do
         expect(collection.first.id).to eq(transaction_id)
       end
 
-      it "searches on reason_codes for 3 items" do
-        reason_code = ["R01", "R02"]
-
-        collection = Braintree::Transaction.search do |search|
-          search.reason_code.in reason_code
-        end
-
-        expect(collection.maximum_size).to eq(3)
-      end
-
-      xit "searches on a reason_code" do
-        # duplicate test
-        reason_code = ["R01"]
-        transaction_id = "ach_txn_ret1"
-
-        collection = Braintree::Transaction.search do |search|
-          search.reason_code.in reason_code
-        end
-
-        expect(collection.maximum_size).to eq(1)
-        expect(collection.first.id).to eq(transaction_id)
-      end
-
       xit "searches on debit_network" do
         transaction = Braintree::Transaction.sale!(
           :amount => Braintree::Test::TransactionAmounts::Authorize,

data/spec/integration/braintree/transaction_spec.rb

@@ -2214,6 +2214,37 @@ describe Braintree::Transaction do
         expect(apple_pay_details.commercial).not_to be_nil
         expect(apple_pay_details.payroll).not_to be_nil
         expect(apple_pay_details.product_id).not_to be_nil
+        expect(apple_pay_details.is_device_token).to eq(true)
+      end
+
+      it "can create a transaction with a fake apple pay mpan nonce" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :payment_method_nonce => Braintree::Test::Nonce::ApplePayMpan,
+        )
+        expect(result.success?).to eq(true)
+        expect(result.transaction).not_to be_nil
+        apple_pay_details = result.transaction.apple_pay_details
+        expect(apple_pay_details).not_to be_nil
+        expect(apple_pay_details.bin).not_to be_nil
+        expect(apple_pay_details.card_type).to eq(Braintree::ApplePayCard::CardType::Visa)
+        expect(apple_pay_details.payment_instrument_name).to eq("Visa 2006")
+        expect(apple_pay_details.source_description).to eq("Visa 2006")
+        expect(apple_pay_details.expiration_month.to_i).to be > 0
+        expect(apple_pay_details.expiration_year.to_i).to be > 0
+        expect(apple_pay_details.cardholder_name).not_to be_nil
+        expect(apple_pay_details.image_url).not_to be_nil
+        expect(apple_pay_details.token).to be_nil
+        expect(apple_pay_details.prepaid).not_to be_nil
+        expect(apple_pay_details.healthcare).not_to be_nil
+        expect(apple_pay_details.debit).not_to be_nil
+        expect(apple_pay_details.durbin_regulated).not_to be_nil
+        expect(apple_pay_details.commercial).not_to be_nil
+        expect(apple_pay_details.payroll).not_to be_nil
+        expect(apple_pay_details.product_id).not_to be_nil
+        expect(apple_pay_details.merchant_token_identifier).not_to be_nil
+        expect(apple_pay_details.is_device_token).to eq(false)
       end
 
       it "can create a vaulted transaction with a fake apple pay nonce" do
@@ -2304,9 +2335,9 @@ describe Braintree::Transaction do
         expect(google_pay_details).not_to be_nil
         expect(google_pay_details.card_type).to eq(Braintree::CreditCard::CardType::MasterCard)
         expect(google_pay_details.virtual_card_type).to eq(Braintree::CreditCard::CardType::MasterCard)
-        expect(google_pay_details.last_4).to eq("4444")
-        expect(google_pay_details.virtual_card_last_4).to eq("4444")
-        expect(google_pay_details.source_description).to eq("MasterCard 4444")
+        expect(google_pay_details.last_4).to eq("0005")
+        expect(google_pay_details.virtual_card_last_4).to eq("0005")
+        expect(google_pay_details.source_description).to eq("MasterCard 0005")
         expect(google_pay_details.expiration_month.to_i).to be > 0
         expect(google_pay_details.expiration_year.to_i).to be > 0
         expect(google_pay_details.google_transaction_id).to eq("google_transaction_id")
@@ -5270,6 +5301,61 @@ describe Braintree::Transaction do
       expect(transaction.shipping_details.international_phone[:national_number]).to eq("3121234567")
     end
 
+    it "accepts processing_merchant_category_code" do
+      result = Braintree::Transaction.sale(
+        :amount => "100.00",
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2028"
+        },
+        :processing_merchant_category_code => "5411",
+      )
+
+      expect(result.success?).to eq(true)
+    end
+
+    it "returns validation error for a too long processing_merchant_category_code" do
+      result = Braintree::Transaction.sale(
+        :amount => "100.00",
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2028"
+        },
+        :processing_merchant_category_code => "54111",
+      )
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:transaction).on(:processing_merchant_category_code)[0].code).to eq(Braintree::ErrorCodes::Transaction::ProcessingMerchantCategoryCodeIsInvalid)
+    end
+
+    it "returns validation error for an alphanumeric processing_merchant_category_code" do
+      result = Braintree::Transaction.sale(
+        :amount => "100.00",
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2028"
+        },
+        :processing_merchant_category_code => "541A",
+      )
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:transaction).on(:processing_merchant_category_code)[0].code).to eq(Braintree::ErrorCodes::Transaction::ProcessingMerchantCategoryCodeIsInvalid)
+    end
+
+    it "returns validation error for a too short processing_merchant_category_code" do
+      result = Braintree::Transaction.sale(
+        :amount => "100.00",
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2028"
+        },
+        :processing_merchant_category_code => "541",
+      )
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:transaction).on(:processing_merchant_category_code)[0].code).to eq(Braintree::ErrorCodes::Transaction::ProcessingMerchantCategoryCodeIsInvalid)
+    end
+
     it "allows merchant account to be specified" do
       result = Braintree::Transaction.sale(
         :amount => Braintree::Test::TransactionAmounts::Authorize,
@@ -6784,6 +6870,34 @@ describe Braintree::Transaction do
       expect(transaction.acquirer_reference_number).to eq("123456789 091019")
     end
 
+    it "finds a transaction and returns a payment_account_reference if the transaction has one" do
+      transaction = Braintree::Transaction.find("aft_txn")
+
+      expect(transaction.credit_card_details).not_to be_nil
+      expect(transaction.credit_card_details).to respond_to(:payment_account_reference)
+    end
+
+    it "finds a transaction and returns a payment_account_reference in apple_pay_details if the transaction has one" do
+      transaction = Braintree::Transaction.find("apple_pay_transaction")
+
+      expect(transaction.apple_pay_details).not_to be_nil
+      expect(transaction.apple_pay_details).to respond_to(:payment_account_reference)
+    end
+
+    it "finds a transaction and returns a payment_account_reference in google_pay_details if the transaction has one" do
+      transaction = Braintree::Transaction.find("android_pay_card_transaction")
+
+      expect(transaction.google_pay_details).not_to be_nil
+      expect(transaction.google_pay_details).to respond_to(:payment_account_reference)
+    end
+
+    it "finds a transaction and returns a payment_account_reference in google_pay_details for network token if the transaction has one" do
+      transaction = Braintree::Transaction.find("android_pay_network_token_transaction")
+
+      expect(transaction.google_pay_details).not_to be_nil
+      expect(transaction.google_pay_details).to respond_to(:payment_account_reference)
+    end
+
     context "disbursement_details" do
       it "includes disbursement_details on found transactions" do
         found_transaction = Braintree::Transaction.find("deposittransaction")

data/spec/integration/braintree/transaction_transfer_type_spec.rb

@@ -42,5 +42,260 @@ describe Braintree::Transaction do
       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/spec_helper.rb

@@ -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"

data/spec/unit/braintree/apple_pay_card_spec.rb

@@ -36,6 +36,7 @@ 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",
@@ -93,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