braintree 4.29.0 → 4.31.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")
@@ -7755,4 +7786,13 @@ describe Braintree::Transaction do
       expect(result.transaction.status).to eq(Braintree::Transaction::Status::SubmittedForSettlement)
     end
   end
+
+  describe "upcoming_retry_date" do
+    it "returns the upcoming retry date for ACH transactions" do
+      transaction = Braintree::Transaction.find("first_attempted_ach_transaction")
+
+      tomorrow = Date.today + 1
+      expect(transaction.upcoming_retry_date).to eq(tomorrow.to_s)
+    end
+  end
 end

data/spec/integration/braintree/transaction_transfer_type_spec.rb

@@ -0,0 +1,301 @@
+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",
+        },
+      }
+
+      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/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

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

data/spec/unit/braintree/dispute_spec.rb

@@ -40,6 +40,7 @@ describe Braintree::Dispute do
           :timestamp => Time.utc(2009, 3, 9, 10, 50, 39),
         }
       ],
+      :remaining_file_evidence_storage => 341029,
       :transaction => {
         :amount => "31.00",
         :id => "open_disputed_transaction",
@@ -436,6 +437,11 @@ describe Braintree::Dispute do
 
       expect(dispute.pre_dispute_program).to eq(Braintree::Dispute::PreDisputeProgram::VisaRdr)
     end
+
+    it "checks that the remaining_file_evidence_storage field is set correctly" do
+      dispute = Braintree::Dispute._new(attributes)
+      dispute.remaining_file_evidence_storage.should == 341029
+    end
   end
 
   describe "==" do