braintree 4.23.0 → 4.34.0

data/spec/unit/braintree/client_token_spec.rb

@@ -33,5 +33,16 @@ module Braintree
         end
       end
     end
+
+    describe "error response handling" do
+      it "correctly parses error response with nested structure" do
+        error_xml = "<api-error-response><message>Invalid request</message><errors><errors type=\"array\"></errors></errors></api-error-response>"
+        result = Braintree::Xml::Parser.hash_from_xml(error_xml)
+
+        expect(result[:api_error_response]).to be_a(Hash)
+        expect(result[:api_error_response][:message]).to eq("Invalid request")
+        expect(result[:api_error_response][:errors]).to be_a(Hash)
+      end
+    end
   end
 end

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,
@@ -266,4 +266,29 @@ describe Braintree::CreditCard do
       end
     end
   end
+
+  it "initializes prepaid reloadable correctly" 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/credit_card_verification_spec.rb

@@ -159,4 +159,21 @@ describe Braintree::CreditCardVerification do
       expect(verification.network_response_text).to eq("Successful approval/completion or V.I.P. PIN verification is successful")
     end
   end
+
+  describe "credit_card with payment_account_reference" do
+    it "includes payment_account_reference in credit_card hash when present" do
+      verification = Braintree::CreditCardVerification._new(
+        :status => "verified",
+        :credit_card => {
+          :bin => "401288",
+          :last_4 => "1881",
+          :card_type => "Visa",
+          :payment_account_reference => "V0010013019339005665779448477"
+        },
+      )
+
+      expect(verification.credit_card).to be_a(Hash)
+      expect(verification.credit_card[:payment_account_reference]).to eq("V0010013019339005665779448477")
+    end
+  end
 end

data/spec/unit/braintree/customer_session_gateway_spec.rb

@@ -0,0 +1,122 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::CustomerSessionGateway do
+  let(:gateway) { double(:gateway) }
+  let(:graphql_client) { double(:graphql_client) }
+  let(:customer_session_gateway) { Braintree::CustomerSessionGateway.new(gateway, graphql_client) }
+
+  describe "#create_customer_session" do
+    let(:input) do
+      {
+       :merchant_account_id => "merchant-account-id",
+      }
+    end
+
+    let(:response) do
+        {
+          data: {
+            createCustomerSession: {
+                sessionId: "session-id"
+            }
+          }
+        }
+    end
+
+
+    it "executes the createCustomerSession mutation" do
+      create_input = Braintree::CreateCustomerSessionInput.new(input)
+      expect(graphql_client).to receive(:query).with(Braintree::CustomerSessionGateway::CREATE_CUSTOMER_SESSION,
+      {
+        "input" => create_input.to_graphql_variables
+      }).and_return(response)
+
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors).with(response).and_return(nil)
+      result = customer_session_gateway.create_customer_session(create_input)
+      expect(result).to be_a(Braintree::SuccessfulResult)
+      expect(result.session_id).to eq("session-id")
+    end
+
+    it "returns an error result if there are validation errors" do
+      create_input = Braintree::CreateCustomerSessionInput.new(input)
+      errors = {:errors =>
+        [ {:attribute => "", :code => "123", :message => "error"} ]
+      }
+      expect(graphql_client).to receive(:query).and_return(response)
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors).with(response).and_return(errors)
+      result = customer_session_gateway.create_customer_session(create_input)
+      expect(result).to be_a(Braintree::ErrorResult)
+      expect(result.errors.first.message).to eq("error")
+    end
+
+    it "raises an UnexpectedError if there is a problem parsing the response" do
+      create_input = Braintree::CreateCustomerSessionInput.new(input)
+      badResonse =  {:data => {}}
+      expect(graphql_client).to receive(:query).and_return(badResonse)
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors).with(badResonse).and_return(nil)
+      expect { customer_session_gateway.create_customer_session(create_input) }.to raise_error(Braintree::UnexpectedError)
+    end
+  end
+
+
+  describe "#update_customer_session" do
+      let(:input) do
+        {
+          :merchant_account_id => "merchant-account-id", :session_id => "session-id"
+        }
+      end
+      let(:response) do
+        {
+          data: {
+            updateCustomerSession: {
+                sessionId: "session-id"
+            }
+          }
+        }
+      end
+
+      it "executes the updateCustomerSession mutation" do
+        update_input = Braintree::UpdateCustomerSessionInput.new(input)
+        expect(graphql_client).to receive(:query).with(Braintree::CustomerSessionGateway::UPDATE_CUSTOMER_SESSION,
+        {
+          "input" => update_input.to_graphql_variables
+        }).and_return(response)
+        expect(Braintree::GraphQLClient).to receive(:get_validation_errors).with(response).and_return(nil)
+        result = customer_session_gateway.update_customer_session(update_input)
+        expect(result).to be_a(Braintree::SuccessfulResult)
+        expect(result.session_id).to eq("session-id")
+      end
+  end
+
+  describe "#get_customer_recommendations" do
+    let(:customer_recommendations_input) { double(:customer_recommendations_input, to_graphql_variables: {"sessionId" => "session_id"}) }
+    let(:response) do
+      {
+        data: {
+          generateCustomerRecommendations: {
+              sessionId: "session_id",
+              isInPayPalNetwork: true,
+              paymentRecommendations:[
+                  {paymentOption: "PAYPAL", recommendedPriority: 1},
+                  {paymentOption: "VENMO", recommendedPriority: 2}
+                ]
+
+          }
+        }
+      }
+    end
+
+    it "fetches customer recommendations" do
+      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.session_id).to eq("session_id")
+      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
+
+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/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

data/spec/unit/braintree/error_result_spec.rb

@@ -14,6 +14,34 @@ describe Braintree::ErrorResult do
         )
       end.to_not raise_error
     end
+
+    it "handles parsed XML error response structure correctly" do
+      data = {
+        :message => "Validation failed",
+        :errors => {
+          :errors => [{:code => "81234", :message => "Field is required"}]
+        }
+      }
+
+      expect do
+        result = Braintree::ErrorResult.new(:gateway, data)
+        expect(result.message).to eq("Validation failed")
+        expect(result.errors.inspect).to eq("#<Braintree::Errors :[(81234) Field is required]>")
+      end.to_not raise_error
+    end
+
+    it "handles empty error array in parsed XML response" do
+      data = {
+        :message => "Invalid request",
+        :errors => {:errors => []}
+      }
+
+      expect do
+        result = Braintree::ErrorResult.new(:gateway, data)
+        expect(result.message).to eq("Invalid request")
+        expect(result.errors).to be_a(Braintree::Errors)
+      end.to_not raise_error
+    end
   end
 
   describe "inspect" do

data/spec/unit/braintree/google_pay_card_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::GooglePayCard do
+  it "initializes prepaid reloadable correctly" 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

@@ -0,0 +1,102 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+
+describe Braintree::CreateCustomerSessionInput do
+  let(:input_data) do
+  {
+    merchant_account_id: "merchant-account-id",
+    session_id: "session-id",
+    customer: {
+      email: "test@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
+
+  describe "#initialize" do
+    it "initializes with attributes" do
+      input = Braintree::CreateCustomerSessionInput.new(input_data)
+
+      expect(input.attrs).to eq(input_data.keys)
+      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.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
+      attributes = {merchant_account_id: "merchant-account-id"}
+      input = Braintree::CreateCustomerSessionInput.new(attributes)
+      expect(input.customer).to be_nil
+    end
+  end
+
+
+  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\" 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
+        attributes = {
+          merchant_account_id: "merchant-account-id",
+          session_id: nil,
+          customer: nil
+        }
+        input = Braintree::CreateCustomerSessionInput.new(attributes)
+        expected_string = "#<Braintree::CreateCustomerSessionInput merchant_account_id:\"merchant-account-id\" session_id:nil customer:nil>"
+
+        expect(input.inspect).to eq(expected_string)
+      end
+
+  end
+
+  describe "#to_graphql_variables" do
+    it "converts the input to graphql variables" do
+      input = Braintree::CreateCustomerSessionInput.new(input_data)
+      expected_variables = {
+        "merchantAccountId" => "merchant-account-id",
+        "sessionId" => "session-id",
+        "domain" => "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)
+
+
+    end
+
+    it "handles nil values" do
+        attributes = {merchant_account_id: "merchant-account-id"}
+        input = Braintree::CreateCustomerSessionInput.new(attributes)
+        expected_variables = {"merchantAccountId" => "merchant-account-id"}
+
+        expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+
+describe Braintree::CustomerRecommendationsInput do
+  let(:input_data) do
+  {
+    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"
+          }
+        }
+      ],
+    domain: "example.com"
+  }
+  end
+  describe "#initialize" do
+    it "initializes with attributes" do
+      input = Braintree::CustomerRecommendationsInput.new(input_data)
+
+      expect(input.attrs).to eq(input_data.keys)
+      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)
+    end
+
+    it "handles nil customer" do
+      attributes = {
+        merchant_account_id: "merchant-account-id",
+        session_id: "session-id"
+      }
+      input = Braintree::CustomerRecommendationsInput.new(attributes)
+
+      expect(input.customer).to be_nil
+    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\" 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 and returns a string representation" do
+        attributes = {
+          merchant_account_id: "merchant-account-id",
+          session_id: "session-id"
+        }
+        input = Braintree::CustomerRecommendationsInput.new(attributes)
+        expected_string = "#<Braintree::CustomerRecommendationsInput merchant_account_id:\"merchant-account-id\" session_id:\"session-id\">"
+
+        expect(input.inspect).to eq(expected_string)
+      end
+
+  end
+
+  describe "#to_graphql_variables" do
+    it "converts the input to graphql variables" do
+      input = Braintree::CustomerRecommendationsInput.new(input_data)
+      expected_variables = {
+        "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"}}],
+        "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/customer_session_input_spec.rb

@@ -0,0 +1,81 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+
+describe Braintree::CustomerSessionInput do
+  let(:input_data) do
+  {
+    email: "test@example.com" ,
+    phone: {
+      country_phone_code: "1",
+      phone_number: "555-123-4567",
+      extension_number: "123",
+    },
+    user_agent: "Mozilla"
+  }
+  end
+
+  describe "#initialize" do
+    it "initializes with attributes" do
+      input = Braintree::CustomerSessionInput.new(input_data)
+
+      expect(input.attrs).to eq(input_data.keys)
+      expect(input.email).to eq("test@example.com")
+      expect(input.phone.country_phone_code).to eq("1")
+      expect(input.phone.phone_number).to eq("555-123-4567")
+      expect(input.phone.extension_number).to eq("123")
+      expect(input.user_agent).to eq("Mozilla")
+    end
+
+    it "handles nil email" do
+      attributes = {}
+      input = Braintree::CustomerSessionInput.new(attributes)
+      expect(input.email).to be_nil
+    end
+  end
+
+
+  describe "#inspect" do
+      it "returns a string representation of the object" do
+        input = Braintree::CustomerSessionInput.new(input_data)
+        expected_string = "#<Braintree::CustomerSessionInput email:\"test@example.com\" phone:#<Braintree::PhoneInput country_phone_code:\"1\" phone_number:\"555-123-4567\" extension_number:\"123\"> user_agent:\"Mozilla\">"
+        expect(input.inspect).to eq(expected_string)
+
+      end
+
+      it "handles nil values" do
+        attributes = {}
+        input = Braintree::CustomerSessionInput.new(attributes)
+        expected_string = "#<Braintree::CustomerSessionInput >"
+
+        expect(input.inspect).to eq(expected_string)
+      end
+
+  end
+
+  describe "#to_graphql_variables" do
+    it "converts the input to graphql variables" do
+      input = Braintree::CustomerSessionInput.new(input_data)
+      expected_variables = {
+        "email" => "test@example.com",
+        "phone" => {
+          "countryPhoneCode" => "1",
+          "phoneNumber" => "555-123-4567",
+          "extensionNumber" => "123"
+        },
+        "userAgent" => "Mozilla"
+      }
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+
+
+    end
+
+    it "handles nil values" do
+        attributes = {}
+        input = Braintree::CustomerSessionInput.new(attributes)
+        expected_variables = {}
+
+        expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+  end
+end