braintree 4.26.0 → 4.28.0

data/spec/integration/braintree/transaction_spec.rb

@@ -280,6 +280,58 @@ describe Braintree::Transaction do
         expect(result.transaction.credit_card_details.prepaid_reloadable).to eq(Braintree::CreditCard::PrepaidReloadable::Yes)
         expect(result.transaction.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::CreditCard)
       end
+
+      it "sets the business field if the card is business" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => 1_00,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Business,
+            :expiration_date => "05/2009"
+          },
+        )
+        expect(result.transaction.credit_card_details.business).to eq(Braintree::CreditCard::Business::Yes)
+        expect(result.transaction.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::CreditCard)
+      end
+
+      it "sets the consumer field if the card is consumer" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => 1_00,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Consumer,
+            :expiration_date => "05/2009"
+          },
+        )
+        expect(result.transaction.credit_card_details.consumer).to eq(Braintree::CreditCard::Consumer::Yes)
+        expect(result.transaction.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::CreditCard)
+      end
+
+      it "sets the corporate field if the card is corporate" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => 1_00,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Corporate,
+            :expiration_date => "05/2009"
+          },
+        )
+        expect(result.transaction.credit_card_details.corporate).to eq(Braintree::CreditCard::Corporate::Yes)
+        expect(result.transaction.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::CreditCard)
+      end
+
+      it "sets the purchase field if the card is purchase" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => 1_00,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Purchase,
+            :expiration_date => "05/2009"
+          },
+        )
+        expect(result.transaction.credit_card_details.purchase).to eq(Braintree::CreditCard::Purchase::Yes)
+        expect(result.transaction.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::CreditCard)
+      end
     end
 
     describe "sca_exemption" do
@@ -1987,108 +2039,6 @@ describe Braintree::Transaction do
       end
     end
 
-    context "service fees" do
-      it "allows specifying service fees" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-          :service_fee_amount => "1.00",
-        )
-        expect(result.success?).to eq(true)
-        expect(result.transaction.service_fee_amount).to eq(BigDecimal("1.00"))
-      end
-
-      it "raises an error if transaction merchant account is a master" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-          :service_fee_amount => "1.00",
-        )
-        expect(result.success?).to eq(false)
-        expected_error_code = Braintree::ErrorCodes::Transaction::ServiceFeeAmountNotAllowedOnMasterMerchantAccount
-        expect(result.errors.for(:transaction).on(:service_fee_amount)[0].code).to eq(expected_error_code)
-      end
-
-      it "raises an error if no service fee is present on a sub merchant account transaction" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-        )
-        expect(result.success?).to eq(false)
-        expected_error_code = Braintree::ErrorCodes::Transaction::SubMerchantAccountRequiresServiceFeeAmount
-        expect(result.errors.for(:transaction).on(:merchant_account_id)[0].code).to eq(expected_error_code)
-      end
-
-      it "raises an error if service fee amount is negative" do
-        result = Braintree::Transaction.create(
-          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-          :service_fee_amount => "-1.00",
-        )
-        expect(result.success?).to eq(false)
-        expect(result.errors.for(:transaction).on(:service_fee_amount)[0].code).to eq(Braintree::ErrorCodes::Transaction::ServiceFeeAmountCannotBeNegative)
-      end
-
-      it "raises an error if service fee amount is invalid" do
-        result = Braintree::Transaction.create(
-          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-          :service_fee_amount => "invalid amount",
-        )
-        expect(result.success?).to eq(false)
-        expect(result.errors.for(:transaction).on(:service_fee_amount)[0].code).to eq(Braintree::ErrorCodes::Transaction::ServiceFeeAmountFormatIsInvalid)
-      end
-    end
-
-    context "escrow" do
-      it "allows specifying transactions to be held for escrow" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-          :service_fee_amount => "10.00",
-          :options => {:hold_in_escrow => true},
-        )
-
-        expect(result.success?).to eq(true)
-        expect(result.transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::HoldPending)
-      end
-
-      it "raises an error if transaction merchant account is a master" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-          :service_fee_amount => "1.00",
-          :options => {:hold_in_escrow => true},
-        )
-        expect(result.success?).to eq(false)
-        expected_error_code = Braintree::ErrorCodes::Transaction::CannotHoldInEscrow
-        expect(result.errors.for(:transaction).on(:base)[0].code).to eq(expected_error_code)
-      end
-    end
-
     context "client API" do
       it "can create a transaction with a shared card nonce" do
         nonce = nonce_for_new_payment_method(
@@ -2183,9 +2133,12 @@ describe Braintree::Transaction do
         meta_checkout_card_details = result.transaction.meta_checkout_card_details
         meta_checkout_card_details.should_not be_nil
         meta_checkout_card_details.bin.should == "401288"
+        meta_checkout_card_details.business.should == "Unknown"
         meta_checkout_card_details.card_type.should == Braintree::CreditCard::CardType::Visa
         meta_checkout_card_details.cardholder_name.should == "Meta Checkout Card Cardholder"
+        meta_checkout_card_details.consumer.should == "Unknown"
         meta_checkout_card_details.container_id.should == "container123"
+        meta_checkout_card_details.corporate.should == "Unknown"
         meta_checkout_card_details.customer_location.should == "US"
         next_year = Date.today().next_year().year.to_s
         meta_checkout_card_details.expiration_date.should == "12/".concat(next_year)
@@ -2197,6 +2150,7 @@ describe Braintree::Transaction do
         meta_checkout_card_details.masked_number.should == "401288******1881"
         meta_checkout_card_details.prepaid.should == "No"
         meta_checkout_card_details.prepaid_reloadable.should == "Unknown"
+        meta_checkout_card_details.purchase.should == "Unknown"
       end
 
       it "can create a transaction with a fake meta checkout token nonce" do
@@ -2212,9 +2166,12 @@ describe Braintree::Transaction do
 
         meta_checkout_token_details.should_not be_nil
         meta_checkout_token_details.bin.should == "401288"
+        meta_checkout_token_details.business.should == "Unknown"
         meta_checkout_token_details.card_type.should == Braintree::CreditCard::CardType::Visa
         meta_checkout_token_details.cardholder_name.should == "Meta Checkout Token Cardholder"
+        meta_checkout_token_details.consumer.should == "Unknown"
         meta_checkout_token_details.container_id.should == "container123"
+        meta_checkout_token_details.corporate.should == "Unknown"
         meta_checkout_token_details.cryptogram.should == "AlhlvxmN2ZKuAAESNFZ4GoABFA=="
         meta_checkout_token_details.customer_location.should == "US"
         meta_checkout_token_details.ecommerce_indicator.should == "07"
@@ -2228,6 +2185,7 @@ describe Braintree::Transaction do
         meta_checkout_token_details.masked_number.should == "401288******1881"
         meta_checkout_token_details.prepaid.should == "No"
         meta_checkout_token_details.prepaid_reloadable.should == "Unknown"
+        meta_checkout_token_details.purchase.should == "Unknown"
       end
 
       it "can create a transaction with a fake apple pay nonce" do
@@ -3005,30 +2963,6 @@ describe Braintree::Transaction do
         expect(result.errors.for(:transaction).for(:three_d_secure_pass_thru).on(:three_d_secure_version)[0].code).to eq(Braintree::ErrorCodes::Transaction::ThreeDSecureThreeDSecureVersionIsInvalid)
       end
 
-      it "returns an error for transaction when the three_d_secure_pass_thru authentication_response is invalid" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => SpecHelper:: AdyenMerchantAccountId,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-          :three_d_secure_pass_thru => {
-            :eci_flag => "05",
-            :cavv => "some_cavv",
-            :xid => "some_xid",
-            :three_d_secure_version => "1.0.2",
-            :authentication_response => "asdf",
-            :directory_response => "Y",
-            :cavv_algorithm => "2",
-            :ds_transaction_id => "some_ds_id",
-          },
-        )
-        expect(result.success?).to eq(false)
-        expect(result.errors.for(:transaction).for(:three_d_secure_pass_thru).on(:authentication_response)[0].code).to eq(Braintree::ErrorCodes::Transaction::ThreeDSecureAuthenticationResponseIsInvalid)
-      end
-
       it "returns an error for transaction when the three_d_secure_pass_thru directory_response is invalid" do
         result = Braintree::Transaction.create(
           :type => "sale",
@@ -5739,7 +5673,6 @@ describe Braintree::Transaction do
       end
     end
 
-
     context "3rd party Card on File Network Token" do
       it "Works with all params" do
         params = {
@@ -6134,24 +6067,6 @@ describe Braintree::Transaction do
       expect(result.errors.for(:transaction).on(:base)[0].code).to eq(Braintree::ErrorCodes::Transaction::CannotSubmitForSettlement)
     end
 
-    context "service fees" do
-      it "returns an error result if amount submitted for settlement is less than service fee amount" do
-        transaction = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "06/2009"
-          },
-          :service_fee_amount => "1.00",
-        ).transaction
-        result = Braintree::Transaction.submit_for_settlement(transaction.id, "0.01")
-        expect(result.success?).to eq(false)
-        expect(result.errors.for(:transaction).on(:amount)[0].code).to eq(Braintree::ErrorCodes::Transaction::SettlementAmountIsLessThanServiceFeeAmount)
-      end
-    end
-
     it "succeeds when industry data is provided" do
       transaction = Braintree::Transaction.create(
         :type => "sale",
@@ -6715,101 +6630,6 @@ describe Braintree::Transaction do
     end
   end
 
-  describe "self.release_from_escrow" do
-    it "returns the transaction if successful" do
-      original_transaction = create_escrowed_transcation
-
-      result = Braintree::Transaction.release_from_escrow(original_transaction.id)
-      expect(result.transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::ReleasePending)
-    end
-
-    it "returns an error result if escrow_status is not HeldForEscrow" do
-      transaction = Braintree::Transaction.sale!(
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2009"
-        },
-        :service_fee_amount => "1.00",
-      )
-
-      expect(transaction.escrow_status).to be_nil
-
-      result = Braintree::Transaction.release_from_escrow(transaction.id)
-      expect(result.errors.for(:transaction).on(:base)[0].code).to eq(Braintree::ErrorCodes::Transaction::CannotReleaseFromEscrow)
-    end
-  end
-
-  describe "self.release_from_escrow!" do
-    it "returns the transaction when successful" do
-      original_transaction = create_escrowed_transcation
-
-      transaction = Braintree::Transaction.release_from_escrow!(original_transaction.id)
-      expect(transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::ReleasePending)
-    end
-
-    it "raises an error when transaction is not successful" do
-      transaction = Braintree::Transaction.sale!(
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2009"
-        },
-        :service_fee_amount => "1.00",
-      )
-
-      expect(transaction.escrow_status).to be_nil
-
-      expect do
-        Braintree::Transaction.release_from_escrow!(transaction.id)
-      end.to raise_error(Braintree::ValidationsFailed)
-    end
-  end
-
-  describe "self.cancel_release" do
-    it "returns the transaction if successful" do
-      transaction = create_escrowed_transcation
-      result = Braintree::Transaction.release_from_escrow(transaction.id)
-      expect(result.transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::ReleasePending)
-
-      result = Braintree::Transaction.cancel_release(transaction.id)
-
-      expect(result.success?).to be(true)
-      expect(result.transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::Held)
-    end
-
-    it "returns an error result if escrow_status is not ReleasePending" do
-      transaction = create_escrowed_transcation
-
-      result = Braintree::Transaction.cancel_release(transaction.id)
-
-      expect(result.success?).to be(false)
-      expect(result.errors.for(:transaction).on(:base)[0].code).to eq(Braintree::ErrorCodes::Transaction::CannotCancelRelease)
-    end
-  end
-
-  describe "self.cancel_release!" do
-    it "returns the transaction when release is cancelled" do
-      transaction = create_escrowed_transcation
-      result = Braintree::Transaction.release_from_escrow(transaction.id)
-      expect(result.transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::ReleasePending)
-
-      transaction = Braintree::Transaction.cancel_release!(transaction.id)
-
-      expect(transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::Held)
-    end
-
-    it "raises an error when release cannot be cancelled" do
-      transaction = create_escrowed_transcation
-
-      expect {
-        transaction = Braintree::Transaction.cancel_release!(transaction.id)
-      }.to raise_error(Braintree::ValidationsFailed)
-    end
-  end
-
   describe "self.credit" do
     it "returns a successful result with type=credit if successful" do
       result = Braintree::Transaction.credit(
@@ -7095,76 +6915,6 @@ describe Braintree::Transaction do
     end
   end
 
-  describe "self.hold_in_escrow" do
-    it "returns the transaction if successful" do
-      result = Braintree::Transaction.create(
-        :type => "sale",
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "12/12",
-        },
-        :service_fee_amount => "10.00",
-      )
-
-      expect(result.transaction.escrow_status).to be_nil
-      result = Braintree::Transaction.hold_in_escrow(result.transaction.id)
-
-      expect(result.success?).to be(true)
-      expect(result.transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::HoldPending)
-    end
-
-    it "returns an error result if the transaction cannot be held in escrow" do
-      transaction = Braintree::Transaction.sale!(
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2009"
-        },
-      )
-
-      result = Braintree::Transaction.hold_in_escrow(transaction.id)
-      expect(result.errors.for(:transaction).on(:base)[0].code).to eq(Braintree::ErrorCodes::Transaction::CannotHoldInEscrow)
-    end
-  end
-
-  describe "self.hold_in_escrow!" do
-    it "returns the transaction if successful" do
-      result = Braintree::Transaction.create(
-        :type => "sale",
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "12/12",
-        },
-        :service_fee_amount => "10.00",
-      )
-
-      expect(result.transaction.escrow_status).to be_nil
-      transaction = Braintree::Transaction.hold_in_escrow!(result.transaction.id)
-
-      expect(transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::HoldPending)
-    end
-
-    it "raises an error if the transaction cannot be held in escrow" do
-      transaction = Braintree::Transaction.sale!(
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2009"
-        },
-      )
-
-      expect do
-        Braintree::Transaction.hold_in_escrow!(transaction.id)
-      end.to raise_error(Braintree::ValidationsFailed)
-    end
-  end
-
   describe "self.void" do
     it "returns a successful result if successful" do
       transaction = Braintree::Transaction.sale!(
@@ -7374,24 +7124,6 @@ describe Braintree::Transaction do
     Braintree::Transaction.find(transaction.id)
   end
 
-  def create_escrowed_transcation
-    transaction = Braintree::Transaction.sale!(
-      :amount => Braintree::Test::TransactionAmounts::Authorize,
-      :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-      :credit_card => {
-        :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2009"
-      },
-      :service_fee_amount => "1.00",
-      :options => {:hold_in_escrow => true},
-    )
-
-    config = Braintree::Configuration.instantiate
-    config.http.put("#{config.base_merchant_path}/transactions/#{transaction.id}/settle")
-    config.http.put("#{config.base_merchant_path}/transactions/#{transaction.id}/escrow")
-    Braintree::Transaction.find(transaction.id)
-  end
-
   context "paypal" do
     it "can create a transaction for a paypal account" do
       result = Braintree::Transaction.sale(

data/spec/spec_helper.rb

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

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",
@@ -41,6 +44,7 @@ describe Braintree::ApplePayCard do
       :prepaid => "No",
       :prepaid_reloadable => "No",
       :product_id => "MAC",
+      :purchase => "No",
       :source_card_last4 => "1234",
       :source_description => "blah",
       :subscriptions => [

data/spec/unit/braintree/configuration_spec.rb

@@ -399,7 +399,7 @@ describe Braintree::Configuration do
 
     it "is qa.braintreegateway.com for qa" do
       Braintree::Configuration.environment = :qa
-      expect(Braintree::Configuration.instantiate.server).to eq("gateway.qa2.braintreepayments.com")
+      expect(Braintree::Configuration.instantiate.server).to eq("gateway.qa.braintreepayments.com")
     end
 
     it "can by changed by configuring the production endpoint" do

data/spec/unit/braintree/credit_card_spec.rb

@@ -25,7 +25,7 @@ describe Braintree::CreditCard do
         :payment_method_nonce,
         {:external_vault=>[:network_transaction_id]},
         {:options => match_array([:make_default, :skip_advanced_fraud_checking, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, # NEXT_MAJOR_VERSION Remove this attribute
-          :fail_on_duplicate_payment_method, :fail_on_duplicate_payment_method_for_customer, :verification_account_type, :verification_currency_iso_code])},
+          :account_information_inquiry, :fail_on_duplicate_payment_method, :fail_on_duplicate_payment_method_for_customer, :verification_account_type, :verification_currency_iso_code])},
         {:billing_address => [
           :company,
           :country_code_alpha2,
@@ -73,7 +73,7 @@ describe Braintree::CreditCard do
         :payment_method_nonce,
         {:external_vault=>[:network_transaction_id]},
         {:options => match_array([:make_default, :skip_advanced_fraud_checking, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, # NEXT_MAJOR_VERSION Remove this attribute
-          :fail_on_duplicate_payment_method, :fail_on_duplicate_payment_method_for_customer, :verification_account_type, :verification_currency_iso_code])},
+          :account_information_inquiry, :fail_on_duplicate_payment_method, :fail_on_duplicate_payment_method_for_customer, :verification_account_type, :verification_currency_iso_code])},
         {:billing_address => [
           :company,
           :country_code_alpha2,
@@ -271,4 +271,24 @@ describe Braintree::CreditCard do
     card = Braintree::CreditCard._new(:gateway, {:prepaid_reloadable => "No"})
     expect(card.prepaid_reloadable).to eq("No")
   end
+
+  it "initializes business correctly" do
+    card = Braintree::CreditCard._new(:gateway, {:business => "No"})
+    expect(card.business).to eq("No")
+  end
+
+  it "initializes consumer correctly" do
+    card = Braintree::CreditCard._new(:gateway, {:consumer => "No"})
+    expect(card.consumer).to eq("No")
+  end
+
+  it "initializes corporate correctly" do
+    card = Braintree::CreditCard._new(:gateway, {:corporate => "No"})
+    expect(card.corporate).to eq("No")
+  end
+
+  it "initializes purchase correctly" do
+    card = Braintree::CreditCard._new(:gateway, {:purchase => "No"})
+    expect(card.purchase).to eq("No")
+  end
 end

data/spec/unit/braintree/credit_card_verification_gateway_spec.rb

@@ -34,6 +34,7 @@ describe Braintree::CreditCardVerificationGateway do
       expect(result.inspect).to include("status")
       expect(result.inspect).to include("intended_transaction_source")
       expect(result.inspect).to include("options")
+      expect(result.inspect).to include("account_information_inquiry")
       expect(result.inspect).to include("account_type")
       expect(result.inspect).to include("amount")
       expect(result.inspect).to include("merchant_account_id")

data/spec/unit/braintree/customer_session_gateway_spec.rb

@@ -88,32 +88,33 @@ describe Braintree::CustomerSessionGateway do
   end
 
   describe "#get_customer_recommendations" do
-    let(:customer_recommendations_input) { double(:customer_recommendations_input, to_graphql_variables: {"sessionId" => "session_id", recommendations: ["PAYMENT_RECOMMENDATIONS"]}) }
+    let(:customer_recommendations_input) { double(:customer_recommendations_input, to_graphql_variables: {"sessionId" => "session_id"}) }
     let(:response) do
       {
         data: {
-          customerRecommendations: {
+          generateCustomerRecommendations: {
+              sessionId: "session_id",
               isInPayPalNetwork: true,
-              recommendations: {
-                paymentOptions: [
-                  {paymentOption: "PAYPAL", recommendedPriority: 1}
+              paymentRecommendations:[
+                  {paymentOption: "PAYPAL", recommendedPriority: 1},
+                  {paymentOption: "VENMO", recommendedPriority: 2}
                 ]
-              }
+
           }
         }
       }
     end
 
     it "fetches customer recommendations" do
-      expected_variables = {"input" => {"sessionId" => "session_id", recommendations: ["PAYMENT_RECOMMENDATIONS"]}}
+      expected_variables = {"input" => {"sessionId" => "session_id"}}
       expect(graphql_client).to receive(:query).with(Braintree::CustomerSessionGateway::GET_CUSTOMER_RECOMMENDATIONS, expected_variables).and_return(response)
       expect(Braintree::GraphQLClient).to receive(:get_validation_errors).with(response).and_return(nil)
 
       result = customer_session_gateway.get_customer_recommendations(customer_recommendations_input)
       expect(result).to be_a(Braintree::SuccessfulResult)
       expect(result.customer_recommendations.is_in_paypal_network).to eq(true)
-      expect(result.customer_recommendations.recommendations.payment_options[0].payment_option).to eq("PAYPAL")
-      expect(result.customer_recommendations.recommendations.payment_options[0].recommended_priority).to eq(1)
+      expect(result.customer_recommendations.recommendations.payment_recommendations[0].payment_option).to eq("PAYPAL")
+      expect(result.customer_recommendations.recommendations.payment_recommendations[0].recommended_priority).to eq(1)
     end
   end
 

data/spec/unit/braintree/customer_spec.rb

@@ -105,7 +105,7 @@ describe Braintree::Customer do
           :payment_method_nonce,
           {:external_vault=>[:network_transaction_id]},
           {:options => match_array([:make_default, :skip_advanced_fraud_checking, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, # NEXT_MAJOR_VERSION Remove this attribute
-            :fail_on_duplicate_payment_method, :verification_account_type, :verification_currency_iso_code])},
+            :account_information_inquiry, :fail_on_duplicate_payment_method, :verification_account_type, :verification_currency_iso_code])},
           {:billing_address => [
             :company,
             :country_code_alpha2,
@@ -202,6 +202,7 @@ describe Braintree::Customer do
           :payment_method_nonce,
           {:external_vault=>[:network_transaction_id]},
           {:options => match_array([
+            :account_information_inquiry,
             :make_default,
             :skip_advanced_fraud_checking,
             :verification_merchant_account_id,

data/spec/unit/braintree/google_pay_card_spec.rb

@@ -5,4 +5,24 @@ describe Braintree::GooglePayCard do
     card = Braintree::GooglePayCard._new(:gateway, {:prepaid_reloadable => "No"})
     expect(card.prepaid_reloadable).to eq("No")
   end
+
+  it "initializes business correctly" do
+    card = Braintree::GooglePayCard._new(:gateway, {:business => "No"})
+    expect(card.business).to eq("No")
+  end
+
+  it "initializes consumer correctly" do
+    card = Braintree::GooglePayCard._new(:gateway, {:consumer => "No"})
+    expect(card.consumer).to eq("No")
+  end
+
+  it "initializes corporate correctly" do
+    card = Braintree::GooglePayCard._new(:gateway, {:corporate => "No"})
+    expect(card.corporate).to eq("No")
+  end
+
+  it "initializes purchase correctly" do
+    card = Braintree::GooglePayCard._new(:gateway, {:purchase => "No"})
+    expect(card.purchase).to eq("No")
+  end
 end