braintree 4.35.0 → 4.36.0

data/spec/integration/braintree/transaction_idempotency_spec.rb

@@ -0,0 +1,320 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::Transaction, "idempotency" do
+  describe "sale" do
+    it "returns original transaction on duplicate request with same api_request_key" do
+      api_request_key = "idempotency-key-#{rand(1000000)}"
+
+      transaction_params = {
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :api_request_key => api_request_key,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      result1 = Braintree::Transaction.sale(transaction_params)
+      expect(result1).to be_success
+      transaction1 = result1.transaction
+      expect(transaction1.id).not_to be_nil
+
+      result2 = Braintree::Transaction.sale(transaction_params)
+      expect(result2).to be_success
+      transaction2 = result2.transaction
+
+      expect(transaction1.status).to eq(transaction2.status)
+      expect(transaction1.id).to eq(transaction2.id)
+    end
+
+    it "fails when different request used with same key" do
+      api_request_key = "idempotency-key-#{rand(1000000)}"
+
+      transaction_params1 = {
+        :amount => "100.00",
+        :api_request_key => api_request_key,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      result1 = Braintree::Transaction.sale(transaction_params1)
+      expect(result1).to be_success
+
+      transaction_params2 = {
+        :amount => "200.00",
+        :api_request_key => api_request_key,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      result2 = Braintree::Transaction.sale(transaction_params2)
+
+      expect(result2).not_to be_success
+      expect(result2.errors).not_to be_nil
+      errors = result2.errors.for(:transaction)
+      expect(errors.size).to be > 0
+      expect(errors.first.code).to eq(Braintree::ErrorCodes::Transaction::ApiRequestKeyCanBeReusedOnlyWithTheSameRequest)
+    end
+
+    it "same sales with different api_request_keys create different transactions" do
+      api_request_key1 = "idempotency-key-#{rand(1000000)}"
+
+      transaction_params1 = {
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :api_request_key => api_request_key1,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      result1 = Braintree::Transaction.sale(transaction_params1)
+      expect(result1).to be_success
+      transaction1 = result1.transaction
+      expect(transaction1.id).not_to be_nil
+
+      api_request_key2 = "idempotency-key-different-#{rand(1000000)}"
+      transaction_params2 = {
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :api_request_key => api_request_key2,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      result2 = Braintree::Transaction.sale(transaction_params2)
+      expect(result2).to be_success
+      transaction2 = result2.transaction
+
+      expect(transaction1.id).not_to eq(transaction2.id)
+    end
+
+    it "fails when api_request_key is too big" do
+      transaction_params1 = {
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :api_request_key => "x" * 255,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      result1 = Braintree::Transaction.sale(transaction_params1)
+      expect(result1).to be_success
+
+      transaction_params2 = {
+        :amount => "200.00",
+        :api_request_key => "x" * 256,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      result2 = Braintree::Transaction.sale(transaction_params2)
+
+      expect(result2).not_to be_success
+      expect(result2.errors).not_to be_nil
+      errors = result2.errors.for(:transaction)
+      expect(errors.size).to be > 0
+      expect(errors.first.code).to eq(Braintree::ErrorCodes::Transaction::ApiRequestKeyTooLong)
+    end
+  end
+
+  describe "credit" do
+    it "returns original on duplicate request with same api_request_key" do
+      api_request_key = "credit-idempotency-key-#{rand(1000000)}"
+
+      transaction_params = {
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :api_request_key => api_request_key,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      credit_result1 = Braintree::Transaction.credit(transaction_params)
+      expect(credit_result1).to be_success
+      credit_transaction1 = credit_result1.transaction
+      expect(credit_transaction1.type).to eq(Braintree::Transaction::Type::Credit)
+      expect(credit_transaction1.id).not_to be_nil
+
+      credit_result2 = Braintree::Transaction.credit(transaction_params)
+      expect(credit_result2).to be_success
+      credit_transaction2 = credit_result2.transaction
+
+      expect(credit_transaction1.id).to eq(credit_transaction2.id)
+      expect(credit_transaction1.type).to eq(credit_transaction2.type)
+    end
+  end
+
+  describe "submit_for_partial_settlement" do
+    it "returns original on duplicate request with same api_request_key" do
+      api_request_key = "partial-settlement-idempotency-key-#{rand(1000000)}"
+
+      sale_request = {
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      sale_result = Braintree::Transaction.sale(sale_request)
+      expect(sale_result).to be_success
+      transaction_id = sale_result.transaction.id
+
+      partial_amount = "50.00"
+      partial_settlement_options = {
+        :api_request_key => api_request_key
+      }
+
+      partial_settlement_result1 = Braintree::Transaction.submit_for_partial_settlement(
+        transaction_id,
+        partial_amount,
+        partial_settlement_options,
+      )
+      expect(partial_settlement_result1).to be_success
+      partial_settlement_transaction1 = partial_settlement_result1.transaction
+      expect(partial_settlement_transaction1.amount).to eq(BigDecimal(partial_amount))
+      expect(partial_settlement_transaction1.id).not_to be_nil
+
+      partial_settlement_result2 = Braintree::Transaction.submit_for_partial_settlement(
+        transaction_id,
+        partial_amount,
+        partial_settlement_options,
+      )
+      expect(partial_settlement_result2).to be_success
+      partial_settlement_transaction2 = partial_settlement_result2.transaction
+
+      expect(partial_settlement_transaction1.id).to eq(partial_settlement_transaction2.id)
+      expect(partial_settlement_transaction1.amount).to eq(partial_settlement_transaction2.amount)
+    end
+  end
+
+  describe "submit_for_settlement" do
+    it "returns original on duplicate request with same api_request_key" do
+      api_request_key = "settlement-idempotency-key-#{rand(1000000)}"
+
+      sale_request = {
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      sale_result = Braintree::Transaction.sale(sale_request)
+      expect(sale_result).to be_success
+      transaction_id = sale_result.transaction.id
+      original_amount = sale_result.transaction.amount
+
+      settlement_options = {
+        :api_request_key => api_request_key
+      }
+
+      settlement_result1 = Braintree::Transaction.submit_for_settlement(
+        transaction_id,
+        nil,
+        settlement_options,
+      )
+      expect(settlement_result1).to be_success
+      settlement_transaction1 = settlement_result1.transaction
+      expect(settlement_transaction1.amount).to eq(original_amount)
+      expect(settlement_transaction1.id).not_to be_nil
+
+      settlement_result2 = Braintree::Transaction.submit_for_settlement(
+        transaction_id,
+        nil,
+        settlement_options,
+      )
+      expect(settlement_result2).to be_success
+      settlement_transaction2 = settlement_result2.transaction
+
+      expect(settlement_transaction1.id).to eq(settlement_transaction2.id)
+      expect(settlement_transaction1.amount).to eq(settlement_transaction2.amount)
+    end
+  end
+
+  describe "void" do
+    it "returns original void on duplicate request with same api_request_key" do
+      api_request_key = "void-idempotency-key-#{rand(1000000)}"
+
+      sale_request = {
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      sale_result = Braintree::Transaction.sale(sale_request)
+      expect(sale_result).to be_success
+      transaction_id = sale_result.transaction.id
+
+      void_options = {
+        :api_request_key => api_request_key
+      }
+
+      void_result1 = Braintree::Transaction.void(transaction_id, void_options)
+      expect(void_result1).to be_success
+      voided_transaction1 = void_result1.transaction
+      expect(voided_transaction1.status).to eq(Braintree::Transaction::Status::Voided)
+
+      void_result2 = Braintree::Transaction.void(transaction_id, void_options)
+      expect(void_result2).to be_success
+      voided_transaction2 = void_result2.transaction
+
+      expect(voided_transaction1.id).to eq(voided_transaction2.id)
+      expect(voided_transaction1.status).to eq(voided_transaction2.status)
+      expect(voided_transaction2.status).to eq(Braintree::Transaction::Status::Voided)
+    end
+  end
+
+  describe "refund" do
+    it "returns original refund on duplicate request with same api_request_key" do
+      api_request_key = "refund-idempotency-key-#{rand(1000000)}"
+
+      sale_request = {
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        },
+        :options => {
+          :submit_for_settlement => true
+        }
+      }
+
+      sale_result = Braintree::Transaction.sale(sale_request)
+      expect(sale_result).to be_success
+      transaction_id = sale_result.transaction.id
+
+      settled_result = Braintree::TestTransaction.settle(transaction_id)
+      expect(settled_result.transaction.status).to eq(Braintree::Transaction::Status::Settled)
+
+      refund_options = {
+        :api_request_key => api_request_key
+      }
+
+      refund_result1 = Braintree::Transaction.refund(transaction_id, refund_options)
+      expect(refund_result1).to be_success
+      refund_transaction1 = refund_result1.transaction
+      expect(refund_transaction1.type).to eq(Braintree::Transaction::Type::Credit)
+      expect(refund_transaction1.id).not_to be_nil
+
+      refund_result2 = Braintree::Transaction.refund(transaction_id, refund_options)
+      expect(refund_result2).to be_success
+      refund_transaction2 = refund_result2.transaction
+
+      expect(refund_transaction1.id).to eq(refund_transaction2.id)
+      expect(refund_transaction1.type).to eq(refund_transaction2.type)
+    end
+  end
+end

data/spec/integration/braintree/transaction_search_spec.rb

@@ -69,6 +69,7 @@ describe Braintree::Transaction, "search" do
       credit_card = Braintree::CreditCard.find(token)
 
       search_criteria = {
+        :acquirer_reference_number => transaction.acquirer_reference_number,
         :billing_company => "Braintree",
         :billing_country_name => "United States of America",
         :billing_extended_address => "Suite 123",
@@ -207,9 +208,9 @@ describe Braintree::Transaction, "search" do
       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_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.")
+      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

data/spec/integration/braintree/transaction_spec.rb

@@ -5324,6 +5324,64 @@ describe Braintree::Transaction do
       expect(transaction.shipping_details.international_phone[:national_number]).to eq("3121234567")
     end
 
+    it "accepts customer international_phone" do
+      result = Braintree::Transaction.sale(
+        :amount => "100.00",
+        :credit_card => {
+          :number => "5105105105105100",
+          :expiration_date => "05/2011",
+        },
+        :customer => {
+          :first_name => "Dan",
+          :last_name => "Smith",
+          :international_phone => {:country_code => "1", :national_number => "3121234567"},
+        },
+      )
+
+      expect(result.success?).to eq(true)
+      transaction = result.transaction
+      expect(transaction.customer_details.first_name).to eq("Dan")
+      expect(transaction.customer_details.last_name).to eq("Smith")
+      expect(transaction.customer_details.international_phone[:country_code]).to eq("1")
+      expect(transaction.customer_details.international_phone[:national_number]).to eq("3121234567")
+    end
+
+    it "returns validation error for an invalid international_phone country code" do
+      result = Braintree::Transaction.sale(
+        :amount => "100.00",
+        :credit_card => {
+          :number => "5105105105105100",
+          :expiration_date => "05/2011",
+        },
+        :customer => {
+          :first_name => "Dan",
+          :last_name => "Smith",
+          :international_phone => {:country_code => "1111", :national_number => "3121234567"},
+        },
+      )
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.map(&:code)).to include(Braintree::ErrorCodes::Customer::InternationalPhoneCountryCodeIsInvalid)
+    end
+
+    it "returns validation error for an invalid international_phone national number" do
+      result = Braintree::Transaction.sale(
+        :amount => "100.00",
+        :credit_card => {
+          :number => "5105105105105100",
+          :expiration_date => "05/2011",
+        },
+        :customer => {
+          :first_name => "Dan",
+          :last_name => "Smith",
+          :international_phone => {:country_code => "1", :national_number => "31212345611111"},
+        },
+      )
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.map(&:code)).to include(Braintree::ErrorCodes::Customer::InternationalPhoneNationalNumberIsInvalid)
+    end
+
     it "accepts processing_merchant_category_code" do
       result = Braintree::Transaction.sale(
         :amount => "100.00",
@@ -7901,4 +7959,21 @@ describe Braintree::Transaction do
       expect(transaction.upcoming_retry_date).to eq(tomorrow.to_s)
     end
   end
+
+  context "Surcharge Amount" do
+    it "accepts surcharge_amount field" do
+      result = Braintree::Transaction.create(
+        :type => "sale",
+        :amount => "10.00",
+        :surcharge_amount => "1.00",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2029"
+        },
+      )
+
+      expect(result.success?).to eq(true)
+      expect(result.transaction.surcharge_amount).to eq(BigDecimal("1.00"))
+    end
+  end
 end

data/spec/integration/braintree/transaction_us_bank_account_spec.rb

@@ -157,7 +157,8 @@ describe Braintree::Transaction do
               },
             )
             expect(result.success?).to eq(true)
-            expect(result.transaction.ach_type).to eq("same_day")
+            # if the test is ran before 2pm - it returns 'same_day', otherwise 'standard'
+            expect(result.transaction.ach_type).to eq("same_day").or eq("standard")
             expect(result.transaction.requested_ach_type).to eq("same_day")
           end
 

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@ unless defined?(SPEC_HELPER_LOADED)
   project_root = File.expand_path(File.dirname(__FILE__) + "/..")
   require "rubygems"
   require "bundler/setup"
+
   require "rspec"
   require "rspec/retry"
   require "pry"
@@ -42,6 +43,7 @@ unless defined?(SPEC_HELPER_LOADED)
     HiperBRLMerchantAccountId = "hiper_brl"
     NonDefaultMerchantAccountId = "sandbox_credit_card_non_default"
     PinlessDebitMerchantAccountId = "pinless_debit"
+    SuspendedAccount = "suspended_account"
     ThreeDSecureMerchantAccountId = "three_d_secure_merchant_account"
     UsBankMerchantAccountId = "us_bank_merchant_account"
 

data/spec/unit/braintree/credit_card_verification_spec.rb

@@ -19,7 +19,7 @@ describe Braintree::CreditCardVerification do
         :network_response_code => "05",
         :network_response_text => "Do not Honor",
       )
-      expect(verification.inspect).to eq(%(#<Braintree::CreditCardVerification amount: "12.45", ani_first_name_response_code: "I", ani_last_name_response_code: "I", avs_error_response_code: "I", avs_postal_code_response_code: "I", avs_street_address_response_code: "I", billing: nil, created_at: nil, credit_card: nil, currency_iso_code: "USD", cvv_response_code: "I", gateway_rejection_reason: nil, id: nil, merchant_account_id: "some_id", network_response_code: "05", network_response_text: "Do not Honor", processor_response_code: "2000", processor_response_text: "Do Not Honor", status: "verified">))
+      expect(verification.inspect).to eq(%(#<Braintree::CreditCardVerification amount: "12.45", ani_first_name_response_code: "I", ani_last_name_response_code: "I", apple_pay: nil, avs_error_response_code: "I", avs_postal_code_response_code: "I", avs_street_address_response_code: "I", billing: nil, created_at: nil, credit_card: nil, currency_iso_code: "USD", cvv_response_code: "I", gateway_rejection_reason: nil, id: nil, merchant_account_id: "some_id", network_response_code: "05", network_response_text: "Do not Honor", processor_response_code: "2000", processor_response_text: "Do Not Honor", status: "verified">))
     end
 
     it "has a status" do

data/spec/unit/braintree/customer_spec.rb

@@ -28,7 +28,8 @@ describe Braintree::Customer do
       expect(output).to include(%q(first_name: "Patrick"))
       expect(output).to include(%q(last_name: "Smith"))
       expect(output).to include(%q(phone: "802-483-5932"))
-      expect(output).to include(%q(international_phone: {:country_code=>"1", :national_number=>"3121234567"}))
+      international_phone_hash = {:country_code => "1", :national_number => "3121234567"}.inspect
+      expect(output).to include("international_phone: #{international_phone_hash}")
       expect(output).to include(%q(website: "patrick.smith.com"))
       expect(output).to include(%q(addresses: []))
       expect(output).to include(%q(credit_cards: []))
@@ -91,6 +92,38 @@ describe Braintree::Customer do
         :device_data,
         :payment_method_nonce,
         {:risk_data => [:customer_browser, :customer_ip]},
+        {:apple_pay_card => [
+          :cardholder_name,
+          :cryptogram,
+          :eci_indicator,
+          :expiration_month,
+          :expiration_year,
+          :network_transaction_id,
+          :number,
+          :token,
+          {:billing_address => [
+            :company,
+            :country_code_alpha2,
+            :country_code_alpha3,
+            :country_code_numeric,
+            :country_name,
+            :extended_address,
+            :first_name,
+            {:international_phone=>[:country_code, :national_number]},
+            :last_name,
+            :locality,
+            :phone_number,
+            :postal_code,
+            :region,
+            :street_address
+          ]},
+          {:options => match_array([
+            :verification_account_type,
+            :verification_amount,
+            :verification_merchant_account_id,
+            :verify_card
+          ])},
+        ]},
         {:credit_card => [
           :billing_address_id,
           :cardholder_name,
@@ -188,6 +221,39 @@ describe Braintree::Customer do
         :device_data,
         :payment_method_nonce,
         :default_payment_method_token,
+        {:apple_pay_card => [
+          :cardholder_name,
+          :cryptogram,
+          :eci_indicator,
+          :expiration_month,
+          :expiration_year,
+          :network_transaction_id,
+          :number,
+          :token,
+          {:billing_address => [
+            :company,
+            :country_code_alpha2,
+            :country_code_alpha3,
+            :country_code_numeric,
+            :country_name,
+            :extended_address,
+            :first_name,
+            {:international_phone=>[:country_code, :national_number]},
+            :last_name,
+            :locality,
+            :phone_number,
+            :postal_code,
+            :region,
+            :street_address
+          ]},
+          {:options => match_array([
+            :make_default,
+            :verification_account_type,
+            :verification_amount,
+            :verification_merchant_account_id,
+            :verify_card
+          ])},
+        ]},
         {:credit_card => [
           :billing_address_id,
           :cardholder_name,

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

@@ -0,0 +1,68 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../spec_helper")
+
+describe Braintree::BillingAddressInput do
+  describe "#initialize" do
+    it "initializes with all attributes" do
+      attributes = {
+        street_address: "123 Main St",
+        extended_address: "Apt 4B",
+        locality: "Mexico City",
+        region: "CDMX",
+        postal_code: "01000",
+        country_code_alpha2: "MX"
+      }
+      input = Braintree::BillingAddressInput.new(attributes)
+
+      expect(input.street_address).to eq("123 Main St")
+      expect(input.extended_address).to eq("Apt 4B")
+      expect(input.locality).to eq("Mexico City")
+      expect(input.region).to eq("CDMX")
+      expect(input.postal_code).to eq("01000")
+      expect(input.country_code_alpha2).to eq("MX")
+    end
+  end
+
+  describe "#to_graphql_variables" do
+    it "converts to graphql variables with camelCase keys" do
+      attributes = {
+        street_address: "123 Main St",
+        locality: "Mexico City",
+        postal_code: "01000",
+        country_code_alpha2: "MX"
+      }
+      input = Braintree::BillingAddressInput.new(attributes)
+      expected_variables = {
+        "streetAddress" => "123 Main St",
+        "locality" => "Mexico City",
+        "postalCode" => "01000",
+        "countryCode" => "MX"
+      }
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+
+    it "omits nil values" do
+      attributes = {street_address: "123 Main St"}
+      input = Braintree::BillingAddressInput.new(attributes)
+      expected_variables = {"streetAddress" => "123 Main St"}
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+  end
+
+  describe "#inspect" do
+    it "returns formatted string" do
+      attributes = {
+        street_address: "123 Main St",
+        locality: "Mexico City",
+        postal_code: "01000"
+      }
+      input = Braintree::BillingAddressInput.new(attributes)
+      result = input.inspect
+
+      expect(result).to include("BillingAddressInput")
+      expect(result).to include("street_address:")
+      expect(result).to include("locality:")
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../spec_helper")
+
+describe Braintree::CreateLocalPaymentContextInput do
+  let(:input_data) do
+    {
+      amount: {value: "10.00", currency_code: "EUR"},
+      type: Braintree::LocalPaymentType::MBWAY,
+      payer_info: {
+        given_name: "John",
+        surname: "Doe"
+      },
+      order_id: "order-123"
+    }
+  end
+
+  describe "#initialize" do
+    it "initializes with attributes" do
+      input = Braintree::CreateLocalPaymentContextInput.new(input_data)
+
+      expect(input.attrs).to eq(input_data.keys)
+      expect(input.type).to eq(Braintree::LocalPaymentType::MBWAY)
+      expect(input.order_id).to eq("order-123")
+      expect(input.amount).to be_a(Braintree::MonetaryAmountInput)
+      expect(input.payer_info).to be_a(Braintree::PayerInfoInput)
+    end
+
+    it "handles nil payer_info" do
+      attributes = {amount: {value: "10.00", currency_code: "EUR"}, type: "OXXO"}
+      input = Braintree::CreateLocalPaymentContextInput.new(attributes)
+      expect(input.payer_info).to be_nil
+    end
+  end
+
+  describe "#to_graphql_variables" do
+    it "converts to graphql variables with camelCase keys" do
+      input = Braintree::CreateLocalPaymentContextInput.new(input_data)
+      expected_variables = {
+        "paymentContext" => {
+          "amount" => {"value" => "10.00", "currencyCode" => "EUR"},
+          "orderId" => "order-123",
+          "payerInfo" => {
+            "givenName" => "John",
+            "surname" => "Doe"
+          },
+          "type" => Braintree::LocalPaymentType::MBWAY
+        }
+      }
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+  end
+
+  describe "#inspect" do
+    it "returns formatted string" do
+      input = Braintree::CreateLocalPaymentContextInput.new(input_data)
+      result = input.inspect
+
+      expect(result).to include("CreateLocalPaymentContextInput")
+      expect(result).to include("amount:")
+      expect(result).to include("type:")
+    end
+  end
+end