braintree 4.27.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
@@ -2081,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)
@@ -2095,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
@@ -2110,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"
@@ -2126,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
@@ -2903,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",
@@ -7718,4 +7754,4 @@ describe Braintree::Transaction do
       expect(result.transaction.status).to eq(Braintree::Transaction::Status::SubmittedForSettlement)
     end
   end
-end
+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",
@@ -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/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

data/spec/unit/braintree/graphql/create_customer_session_input_spec.rb

@@ -9,7 +9,19 @@ describe Braintree::CreateCustomerSessionInput do
     customer: {
       email: "test@example.com" ,
     },
-    domain: "example.com"
+    domain: "example.com",
+    purchase_units: [
+      {
+        amount: {
+          value: "100.00",
+          currency_code: "USD"
+        },
+        payee: {
+          email_address: "merchant@example.com",
+          client_id: "client-123"
+        }
+      }
+    ]
   }
   end
 
@@ -23,6 +35,10 @@ describe Braintree::CreateCustomerSessionInput do
       expect(input.customer).to be_a(Braintree::CustomerSessionInput)
       expect(input.customer.email).to eq("test@example.com")
       expect(input.domain).to eq("example.com")
+      expect(input.purchase_units).to be_a(Array)
+      expect(input.purchase_units.first).to be_a(Braintree::PayPalPurchaseUnitInput)
+      expect(input.purchase_units.first.amount.value).to eq("100.00")
+      expect(input.purchase_units.first.payee.email_address).to eq("merchant@example.com")
     end
 
     it "handles nil customer" do
@@ -36,9 +52,8 @@ describe Braintree::CreateCustomerSessionInput do
   describe "#inspect" do
       it "returns a string representation of the object" do
         input = Braintree::CreateCustomerSessionInput.new(input_data)
-        expected_string = "#<Braintree::CreateCustomerSessionInput merchant_account_id:\"merchant-account-id\" session_id:\"session-id\" customer:#<Braintree::CustomerSessionInput email:\"test@example.com\"> domain:\"example.com\">"
+        expected_string = "#<Braintree::CreateCustomerSessionInput merchant_account_id:\"merchant-account-id\" session_id:\"session-id\" customer:#<Braintree::CustomerSessionInput email:\"test@example.com\"> domain:\"example.com\" purchase_units:[#<Braintree::PayPalPurchaseUnitInput amount:#<Braintree::MonetaryAmountInput value:\"100.00\" currency_code:\"USD\"> payee:#<Braintree::PayPalPayeeInput email_address:\"merchant@example.com\" client_id:\"client-123\">>]>"
         expect(input.inspect).to eq(expected_string)
-
       end
 
       it "handles nil values" do
@@ -62,7 +77,13 @@ describe Braintree::CreateCustomerSessionInput do
         "merchantAccountId" => "merchant-account-id",
         "sessionId" => "session-id",
         "domain" => "example.com",
-        "customer" => {"email" => "test@example.com"}
+        "customer" => {"email" => "test@example.com"},
+        "purchaseUnits" => [
+          {
+            "amount" => {"value" => "100.00", "currencyCode" => "USD"},
+            "payee" => {"emailAddress" => "merchant@example.com", "clientId" => "client-123"}
+          }
+        ]
       }
 
       expect(input.to_graphql_variables).to eq(expected_variables)

data/spec/unit/braintree/graphql/customer_recommendations_input_spec.rb

@@ -6,8 +6,20 @@ describe Braintree::CustomerRecommendationsInput do
   {
     merchant_account_id: "merchant-account-id",
     session_id: "session-id",
-    recommendations: ["PAYMENT_RECOMMENDATIONS"],
-    customer: {email: "test@example.com"}
+    customer: {email: "test@example.com"},
+    purchase_units: [
+        {
+          amount: {
+            value: "100.00",
+            currency_code: "USD"
+          },
+          payee: {
+            email_address: "merchant@example.com",
+            client_id: "client-123"
+          }
+        }
+      ],
+    domain: "example.com"
   }
   end
   describe "#initialize" do
@@ -18,34 +30,12 @@ describe Braintree::CustomerRecommendationsInput do
       expect(input.merchant_account_id).to eq("merchant-account-id")
       expect(input.session_id).to eq("session-id")
       expect(input.customer).to be_a(Braintree::CustomerSessionInput)
-      expect(input.recommendations[0]).to eq("PAYMENT_RECOMMENDATIONS")
-    end
-
-    it "disallows nil session id" do
-      attributes = {
-        merchant_account_id: "merchant-account-id",
-        recommendations: ["PAYMENT_RECOMMENDATIONS"],
-      }
-      expect do
-        Braintree::CustomerRecommendationsInput.new(attributes)
-      end.to raise_error(ArgumentError, "Expected hash to contain a :session_id")
-    end
-
-    it "disallows nil recommendations" do
-      attributes = {
-        merchant_account_id: "merchant-account-id",
-        session_id: "session-id",
-      }
-      expect do
-        Braintree::CustomerRecommendationsInput.new(attributes)
-      end.to raise_error(ArgumentError, "Expected hash to contain a :recommendations")
     end
 
     it "handles nil customer" do
       attributes = {
         merchant_account_id: "merchant-account-id",
-        session_id: "session-id",
-        recommendations: ["PAYMENT_RECOMMENDATIONS"],
+        session_id: "session-id"
       }
       input = Braintree::CustomerRecommendationsInput.new(attributes)
 
@@ -53,23 +43,20 @@ describe Braintree::CustomerRecommendationsInput do
     end
   end
 
-
   describe "#inspect" do
       it "returns a string representation of the object" do
         input = Braintree::CustomerRecommendationsInput.new(input_data)
-        expected_string = "#<Braintree::CustomerRecommendationsInput merchant_account_id:\"merchant-account-id\" session_id:\"session-id\" recommendations:[\"PAYMENT_RECOMMENDATIONS\"] customer:#<Braintree::CustomerSessionInput email:\"test@example.com\">>"
+        expected_string = "#<Braintree::CustomerRecommendationsInput merchant_account_id:\"merchant-account-id\" session_id:\"session-id\" customer:#<Braintree::CustomerSessionInput email:\"test@example.com\"> purchase_units:[#<Braintree::PayPalPurchaseUnitInput amount:#<Braintree::MonetaryAmountInput value:\"100.00\" currency_code:\"USD\"> payee:#<Braintree::PayPalPayeeInput email_address:\"merchant@example.com\" client_id:\"client-123\">>] domain:\"example.com\">"
         expect(input.inspect).to eq(expected_string)
-
       end
 
-      it "handles nil values" do
+      it "handles nil values and returns a string representation" do
         attributes = {
           merchant_account_id: "merchant-account-id",
-          session_id: "session-id",
-          recommendations: ["PAYMENT_RECOMMENDATIONS"],
+          session_id: "session-id"
         }
         input = Braintree::CustomerRecommendationsInput.new(attributes)
-        expected_string = "#<Braintree::CustomerRecommendationsInput merchant_account_id:\"merchant-account-id\" session_id:\"session-id\" recommendations:[\"PAYMENT_RECOMMENDATIONS\"]>"
+        expected_string = "#<Braintree::CustomerRecommendationsInput merchant_account_id:\"merchant-account-id\" session_id:\"session-id\">"
 
         expect(input.inspect).to eq(expected_string)
       end
@@ -83,28 +70,11 @@ describe Braintree::CustomerRecommendationsInput do
         "merchantAccountId" => "merchant-account-id",
         "sessionId" => "session-id",
         "customer" => {"email" => "test@example.com"},
-        "recommendations" => ["PAYMENT_RECOMMENDATIONS"],
-      }
-
-      expect(input.to_graphql_variables).to eq(expected_variables)
-    end
-
-    it "handles nil values" do
-      attributes = {
-        merchant_account_id: "merchant-account-id",
-        session_id: "session-id",
-        recommendations: ["PAYMENT_RECOMMENDATIONS"],
-      }
-      input = Braintree::CustomerRecommendationsInput.new(attributes)
-
-      expected_variables = {
-        "merchantAccountId" => "merchant-account-id",
-        "sessionId" => "session-id",
-        "recommendations" => ["PAYMENT_RECOMMENDATIONS"],
+        "purchaseUnits" => [{"amount"=>{"currencyCode"=>"USD", "value"=>"100.00"}, "payee"=>{"clientId"=>"client-123", "emailAddress"=>"merchant@example.com"}}],
+        "domain" => "example.com"
       }
 
       expect(input.to_graphql_variables).to eq(expected_variables)
     end
   end
-
 end

data/spec/unit/braintree/graphql/customer_recommendations_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Braintree::CustomerRecommendations do
+  let(:recommendation_data) do
+    [
+      {
+        paymentOption: "PAYPAL",
+        recommendedPriority: 1
+      },
+      {
+        paymentOption: "VENMO",
+        recommendedPriority: 2
+      }
+    ]
+  end
+
+  describe "#initialize" do
+    it "creates payment_recommendations correctly" do
+      recs = Braintree::CustomerRecommendations.new(payment_recommendations: recommendation_data)
+      expect(recs.payment_recommendations.size).to eq(2)
+      expect(recs.payment_recommendations.first).to be_a(Braintree::PaymentRecommendations)
+      expect(recs.payment_recommendations.first.payment_option).to eq("PAYPAL")
+      expect(recs.payment_recommendations.last.payment_option).to eq("VENMO")
+    end
+
+    it "creates payment_options from payment_recommendations" do
+      recs = Braintree::CustomerRecommendations.new(payment_recommendations: recommendation_data)
+      expect(recs.payment_options.size).to eq(2)
+      expect(recs.payment_options.first).to be_a(Braintree::PaymentOptions)
+      expect(recs.payment_options.first.payment_option).to eq("PAYPAL")
+      expect(recs.payment_options.last.payment_option).to eq("VENMO")
+    end
+
+    it "is null safe if no recommendations are passed in" do
+      recs = Braintree::CustomerRecommendations.new
+      expect(recs.payment_recommendations).to eq([])
+      expect(recs.payment_options).to eq([])
+    end
+  end
+end

data/spec/unit/braintree/graphql/update_customer_session_input_spec.rb

@@ -3,11 +3,25 @@ require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
 
 describe Braintree::UpdateCustomerSessionInput do
   let(:input_data) do
-  {
-    merchant_account_id: "merchant-account-id",
-    session_id: "session-id",
-    customer: {email: "test@example.com"}
-  }
+    {
+      merchant_account_id: "merchant-account-id",
+      session_id: "session-id",
+      customer: {
+        email: "test@example.com"
+      },
+      purchase_units: [
+        {
+          amount: {
+            value: "100.00",
+            currency_code: "USD"
+          },
+          payee: {
+            email_address: "merchant@example.com",
+            client_id: "client-123"
+          }
+        }
+      ]
+    }
   end
   describe "#initialize" do
     it "initializes with attributes" do
@@ -44,9 +58,8 @@ describe Braintree::UpdateCustomerSessionInput do
   describe "#inspect" do
       it "returns a string representation of the object" do
         input = Braintree::UpdateCustomerSessionInput.new(input_data)
-        expected_string = "#<Braintree::UpdateCustomerSessionInput merchant_account_id:\"merchant-account-id\" session_id:\"session-id\" customer:#<Braintree::CustomerSessionInput email:\"test@example.com\">>"
+        expected_string = "#<Braintree::UpdateCustomerSessionInput merchant_account_id:\"merchant-account-id\" session_id:\"session-id\" customer:#<Braintree::CustomerSessionInput email:\"test@example.com\"> purchase_units:[#<Braintree::PayPalPurchaseUnitInput amount:#<Braintree::MonetaryAmountInput value:\"100.00\" currency_code:\"USD\"> payee:#<Braintree::PayPalPayeeInput email_address:\"merchant@example.com\" client_id:\"client-123\">>]>"
         expect(input.inspect).to eq(expected_string)
-
       end
 
       it "handles nil values" do
@@ -69,6 +82,7 @@ describe Braintree::UpdateCustomerSessionInput do
         "merchantAccountId" => "merchant-account-id",
         "sessionId" => "session-id",
         "customer" => {"email" => "test@example.com"},
+        "purchaseUnits" => [{"amount"=>{"currencyCode"=>"USD", "value"=>"100.00"}, "payee"=>{"clientId"=>"client-123", "emailAddress"=>"merchant@example.com"}}],
       }
 
       expect(input.to_graphql_variables).to eq(expected_variables)

data/spec/unit/braintree/meta_checkout_card_spec.rb

@@ -4,10 +4,13 @@ describe Braintree::MetaCheckoutCard do
   let(:attributes) do {
 
     :bin => "abc1234",
+    :business => "NO",
     :card_type => "Visa",
     :cardholder_name => "Meta Checkout Card CardHolder",
     :commercial => "NO",
+    :consumer => "NO",
     :container_id => "a-container-id",
+    :corporate => "NO",
     :country_of_issuance => "US",
     :created_at => "2023-05-05T21:28:37Z",
     :debit => "NO",
@@ -19,6 +22,7 @@ describe Braintree::MetaCheckoutCard do
     :payroll => "NO",
     :prepaid => "NO",
     :prepaid_reloadable => "NO",
+    :purchase => "NO",
     :token => "token1",
     :unique_number_identifier => "abc1234",
     :updated_at => "2023-05-05T21:28:37Z"
@@ -30,10 +34,13 @@ describe Braintree::MetaCheckoutCard do
       card = Braintree::MetaCheckoutCard._new(:gateway, attributes)
 
       card.bin.should == "abc1234"
+      card.business.should == "NO"
       card.card_type.should == "Visa"
       card.cardholder_name.should == "Meta Checkout Card CardHolder"
       card.commercial == "NO"
+      card.consumer == "NO"
       card.container_id.should == "a-container-id"
+      card.corporate == "NO"
       card.country_of_issuance == "US"
       card.created_at == "2023-05-05T21:28:37Z"
       card.debit == "NO"
@@ -44,6 +51,7 @@ describe Braintree::MetaCheckoutCard do
       card.payroll == "NO"
       card.prepaid == "NO"
       card.prepaid_reloadable == "NO"
+      card.purchase == "NO"
       card.token == "token1"
       card.unique_number_identifier == "abc1234"
       card.updated_at == "2023-05-05T21:28:37Z"

data/spec/unit/braintree/meta_checkout_token_spec.rb

@@ -3,10 +3,13 @@ require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 describe Braintree::MetaCheckoutToken do
     let(:attributes) do {
         :bin => "abc1234",
+        :business => "NO",
         :container_id => "a-container-id",
         :card_type => "Visa",
         :cardholder_name => "Meta Checkout Card CardHolder",
         :commercial => "NO",
+        :consumer => "NO",
+        :corporate => "NO",
         :country_of_issuance => "US",
         :created_at => "2023-05-05T21:28:37Z",
         :debit => "NO",
@@ -18,6 +21,7 @@ describe Braintree::MetaCheckoutToken do
         :payroll => "NO",
         :prepaid => "NO",
         :prepaid_reloadable => "NO",
+        :purchase => "NO",
         :token => "token1",
         :unique_number_identifier => "abc1234",
         :updated_at => "2023-05-05T21:28:37Z",

data/spec/unit/braintree/payment_method_nonce_spec.rb

@@ -15,8 +15,12 @@ describe Braintree::PaymentMethodNonce do
         :liability_shifted => false
       },
       :bin_data => {
+        :business => "No",
+        :consumer => "No",
+        :corporate => "No",
         :country_of_issuance => "USA",
-        :prepaid_reloadable => "Yes"
+        :prepaid_reloadable => "Yes",
+        :purchase => "No",
       },
     )
   }
@@ -29,9 +33,12 @@ describe Braintree::PaymentMethodNonce do
       expect(payment_method_nonce.details.bin).to eq("some-bin")
       expect(payment_method_nonce.three_d_secure_info.liability_shift_possible).to be false
       expect(payment_method_nonce.three_d_secure_info.liability_shifted).to be false
+      expect(payment_method_nonce.bin_data.business).to eq("No")
+      expect(payment_method_nonce.bin_data.consumer).to eq("No")
+      expect(payment_method_nonce.bin_data.corporate).to eq("No")
       expect(payment_method_nonce.bin_data.country_of_issuance).to eq("USA")
       expect(payment_method_nonce.bin_data.prepaid_reloadable).to eq("Yes")
-
+      expect(payment_method_nonce.bin_data.purchase).to eq("No")
     end
   end